Fix cancellation support to synchronization

Introduces cancellation functionality to the synchronization process. This allows users to interrupt long-running synchronization tasks.

This change includes:
- Passing an optional cancellation callback function to Ledger client methods and synchronization service functions.
- Checking for cancellation requests before and after Ledger interactions.
- Updating tests to reflect the new cancellation parameter.
- Moving type definitions for better organization.

Author: ioanSflt

components/sections/migrate/index-input-section.tsx

@@ -3,9 +3,9 @@ import { Alert, AlertDescription } from '@/components/ui/alert'
 import { Button } from '@/components/ui/button'
 import { Input } from '@/components/ui/input'
 import { Tabs, TabsContent, TabsList, TabsTrigger } from '@/components/ui/tabs'
-import type { ScanType, RangeField } from '@/lib/types/scan'
-import { SCAN_LIMITS, ScanTypeEnum, RangeFieldEnum } from '@/lib/types/scan'
-import { adjustIndexValue, getIndexCount, isRangeExceedsLimit, getPluralForm } from '@/lib/utils/scan-indices'
+import type { RangeField, ScanType } from '@/lib/types/scan'
+import { RangeFieldEnum, SCAN_LIMITS, ScanTypeEnum } from '@/lib/types/scan'
+import { adjustIndexValue, getIndexCount, getPluralForm, isRangeExceedsLimit } from '@/lib/utils/scan-indices'
 
 interface IndexInputSectionProps {
   title: string

lib/services/__tests__/synchronization.service.test.ts

@@ -209,7 +209,7 @@ describe('Synchronization Service', () => {
 
       const result = await synchronizeAppAccounts(mockApp, [], true)
 
-      expect(ledgerClient.synchronizeAccounts).toHaveBeenCalledWith(mockApp)
+      expect(ledgerClient.synchronizeAccounts).toHaveBeenCalledWith(mockApp, undefined)
       expect(result.app.status).toBe(AppStatus.SYNCHRONIZED)
     })
 
@@ -257,7 +257,7 @@ describe('Synchronization Service', () => {
       expect(result.id).toBe(mockApp.id)
       expect(result.name).toBe(mockApp.name)
       expect(result.status).toBe(AppStatus.SYNCHRONIZED)
-      expect(ledgerClient.synchronizeAccountsWithIndices).toHaveBeenCalledWith(mockApp, accountIndices, addressIndices)
+      expect(ledgerClient.synchronizeAccountsWithIndices).toHaveBeenCalledWith(mockApp, accountIndices, addressIndices, undefined)
       expect(processAccountsForApp).toHaveBeenCalledWith(
         mockSyncResult.result,
         mockApp,
@@ -361,7 +361,7 @@ describe('Synchronization Service', () => {
       expect(result.id).toBe('polkadot')
       expect(result.name).toBe('Polkadot')
       expect(result.status).toBe(AppStatus.SYNCHRONIZED)
-      expect(ledgerClient.synchronizeAccounts).toHaveBeenCalledWith(mockApp)
+      expect(ledgerClient.synchronizeAccounts).toHaveBeenCalledWith(mockApp, undefined)
     })
 
     it('should handle errors during Polkadot synchronization', async () => {

lib/services/synchronization.service.ts

@@ -66,12 +66,13 @@ function getAppsToSync(): AppConfig[] {
  * for the specified blockchain application. This is the first step in the synchronization process.
  *
  * @param {AppConfig} appConfig - The blockchain application configuration
+ * @param {() => boolean} [onCancel] - Optional cancellation callback function
  * @returns {Promise<Address[]>} Array of addresses retrieved from the Ledger device
  * @throws {InternalError} When Ledger communication fails or returns no results
  */
-async function fetchAddressesFromLedger(appConfig: AppConfig): Promise<Address[]> {
+async function fetchAddressesFromLedger(appConfig: AppConfig, onCancel?: () => boolean): Promise<Address[]> {
   try {
-    const response = await ledgerClient.synchronizeAccounts(appConfig)
+    const response = await ledgerClient.synchronizeAccounts(appConfig, onCancel)
 
     if (!response.result) {
       throw new InternalError(InternalErrorType.SYNC_ERROR, {
@@ -108,14 +109,21 @@ async function fetchAddressesFromLedger(appConfig: AppConfig): Promise<Address[]
 export async function synchronizeAppAccounts(
   appConfig: AppConfig,
   polkadotAddresses: string[],
-  filterByBalance = true
+  filterByBalance = true,
+  onCancel?: () => boolean
 ): Promise<{
   app: App
   polkadotAddressesForApp: string[]
 }> {
   try {
+    // Check for cancellation before starting
+    checkCancellation(onCancel)
+
     // Fetch addresses from Ledger
-    const addresses = await fetchAddressesFromLedger(appConfig)
+    const addresses = await fetchAddressesFromLedger(appConfig, onCancel)
+
+    // Check for cancellation after fetching addresses
+    checkCancellation(onCancel)
 
     if (!appConfig.rpcEndpoints || appConfig.rpcEndpoints.length === 0) {
       throw new InternalError(InternalErrorType.SYNC_ERROR, {
@@ -236,10 +244,10 @@ export async function synchronizeAppAccounts(
  * const destinationAddresses = polkadotApp.accounts?.map(acc => acc.address) || []
  * ```
  */
-export async function synchronizePolkadotAccounts(): Promise<App> {
+export async function synchronizePolkadotAccounts(onCancel?: () => boolean): Promise<App> {
   try {
     const appConfig = polkadotAppConfig
-    const response = await ledgerClient.synchronizeAccounts(appConfig)
+    const response = await ledgerClient.synchronizeAccounts(appConfig, onCancel)
 
     const noAccountsNotification = {
       title: 'No Polkadot accounts found',
@@ -339,12 +347,13 @@ export async function synchronizePolkadotAccounts(): Promise<App> {
 export async function synchronizeSingleApp(
   appConfig: AppConfig,
   polkadotAddresses: string[],
-  filterByBalance = true
+  filterByBalance = true,
+  onCancel?: () => boolean
 ): Promise<{
   app: App
   polkadotAddresses: string[]
 }> {
-  const { app, polkadotAddressesForApp } = await synchronizeAppAccounts(appConfig, polkadotAddresses, filterByBalance)
+  const { app, polkadotAddressesForApp } = await synchronizeAppAccounts(appConfig, polkadotAddresses, filterByBalance, onCancel)
   return {
     app,
     polkadotAddresses: polkadotAddressesForApp,
@@ -379,7 +388,7 @@ export async function scanAppWithCustomIndices(
     checkCancellation(onCancel)
 
     // Fetch addresses from Ledger using custom indices
-    const addresses = await ledgerClient.synchronizeAccountsWithIndices(appConfig, accountIndices, addressIndices)
+    const addresses = await ledgerClient.synchronizeAccountsWithIndices(appConfig, accountIndices, addressIndices, onCancel)
 
     // Check for cancellation after Ledger interaction
     checkCancellation(onCancel)
@@ -507,7 +516,7 @@ export async function synchronizeAllApps(
     })
 
     // Synchronize Polkadot accounts first
-    const polkadotApp = await synchronizePolkadotAccounts()
+    const polkadotApp = await synchronizePolkadotAccounts(onCancel)
     const polkadotAddresses = polkadotApp.accounts?.map(account => account.address) || []
 
     // Get apps to synchronize (exclude Polkadot since it's handled separately)
@@ -552,7 +561,12 @@ export async function synchronizeAllApps(
       onAppStart?.(loadingApp)
 
       try {
-        const { app, polkadotAddressesForApp: appPolkadotAddresses } = await synchronizeAppAccounts(appConfig, polkadotAddresses)
+        const { app, polkadotAddressesForApp: appPolkadotAddresses } = await synchronizeAppAccounts(
+          appConfig,
+          polkadotAddresses,
+          true,
+          onCancel
+        )
         synchronizedApps.push(app)
         polkadotAddressesForApp[app.id] = appPolkadotAddresses
 

lib/utils/scan-indices.ts

@@ -1,5 +1,5 @@
 import type { IndexConfig, RangeField, RangeIndexConfig, ScanType, SingleIndexConfig, ValidationResult } from '@/lib/types/scan'
-import { SCAN_LIMITS, ScanTypeEnum, RangeFieldEnum } from '@/lib/types/scan'
+import { RangeFieldEnum, SCAN_LIMITS, ScanTypeEnum } from '@/lib/types/scan'
 
 /**
  * Type guard to check if scan type is 'single'

state/client/__tests__/ledger.test.tsx

@@ -206,7 +206,7 @@ describe('Ledger Client', () => {
         .mockResolvedValueOnce(mockAddresses[1])
         .mockResolvedValueOnce(mockAddresses[2])
 
-      const result = await ledgerClient.synchronizeAccounts(mockAppConfig)
+      const result = await ledgerClient.synchronizeAccounts(mockAppConfig, undefined)
 
       expect(result).toEqual({
         result: [
@@ -226,7 +226,7 @@ describe('Ledger Client', () => {
         .mockResolvedValueOnce(undefined)
         .mockRejectedValueOnce(new Error('Address fetch failed'))
 
-      const result = await ledgerClient.synchronizeAccounts(mockAppConfig)
+      const result = await ledgerClient.synchronizeAccounts(mockAppConfig, undefined)
 
       expect(result).toEqual({
         result: [{ ...mockAddress, path: "m/44'/354'/0'/0'/0'" }],
@@ -236,7 +236,7 @@ describe('Ledger Client', () => {
     it('should handle ledger service errors', async () => {
       vi.mocked(ledgerService.getAccountAddress).mockRejectedValue(new Error('Ledger error'))
 
-      await expect(ledgerClient.synchronizeAccounts(mockAppConfig)).rejects.toThrow(InternalError)
+      await expect(ledgerClient.synchronizeAccounts(mockAppConfig, undefined)).rejects.toThrow(InternalError)
     })
   })
 

state/client/ledger.tsx

@@ -64,16 +64,22 @@ export const ledgerClient = {
     })
   },
 
-  async synchronizeAccounts(app: AppConfig): Promise<{ result?: Address[] }> {
+  async synchronizeAccounts(app: AppConfig, onCancel?: () => boolean): Promise<{ result?: Address[] }> {
     return withErrorHandling(
       async () => {
         // fetch addresses
         const addresses: Address[] = []
         for (let i = 0; i < maxAddressesToFetch; i++) {
+          // Check for cancellation before fetching each address
+          if (onCancel?.()) {
+            return { result: undefined }
+          }
+
           try {
             const derivedPath = updateBip44PathIndices(app.bip44Path, { address: i })
             const address = await ledgerService.getAccountAddress(derivedPath, app.ss58Prefix, false)
-            if (address) {
+            if (address && !onCancel?.()) {
+              // Double-check cancellation before adding
               addresses.push({ ...address, path: derivedPath } as Address)
             }
           } catch {
@@ -100,7 +106,8 @@ export const ledgerClient = {
   async synchronizeAccountsWithIndices(
     app: AppConfig,
     accountIndices: number[],
-    addressIndices: number[]
+    addressIndices: number[],
+    onCancel?: () => boolean
   ): Promise<{ result?: Address[] }> {
     return withErrorHandling(
       async () => {
@@ -109,6 +116,11 @@ export const ledgerClient = {
         // Process accounts and addresses sequentially
         for (const accountIndex of accountIndices) {
           for (const addressIndex of addressIndices) {
+            // Check for cancellation before fetching each address
+            if (onCancel?.()) {
+              throw new Error('Synchronization was cancelled')
+            }
+
             try {
               // Build the derivation path with both account and address indices using the robust utility
               const derivedPath = updateBip44PathIndices(app.bip44Path, {
@@ -117,7 +129,8 @@ export const ledgerClient = {
               })
 
               const address = await ledgerService.getAccountAddress(derivedPath, app.ss58Prefix, false)
-              if (address) {
+              if (address && !onCancel?.()) {
+                // Double-check cancellation before adding
                 addresses.push({ ...address, path: derivedPath } as Address)
               }
             } catch (error) {

state/ledger.ts

@@ -381,7 +381,9 @@ export const ledgerState$ = observable({
       const polkadotAccounts = ledgerState$.apps.polkadotApp.get().accounts || []
       const polkadotAddresses = polkadotAccounts.map(account => account.address)
 
-      const { app, polkadotAddressesForApp } = await synchronizeAppAccounts(appConfig, polkadotAddresses)
+      const { app, polkadotAddressesForApp } = await synchronizeAppAccounts(appConfig, polkadotAddresses, true, () =>
+        ledgerState$.apps.isSyncCancelRequested.get()
+      )
       if (app) {
         updateApp(appId, app)
         ledgerState$.polkadotAddresses[appId].set(polkadotAddressesForApp)