fix: add stronghold migration for seed backup (#8674)

* fix: add stornghold migration for seed backup

* fix: error message handling

* fix:add info when profile needs migration

* fix: open chrome link in external browser

* fix: unlocking strongholds

* fix: close popup on error

---------

Co-authored-by: Begoña Álvarez de la Cruz <[email protected]>

Author: brancoder

packages/desktop/components/popups/AppDeprecationPopup.svelte

@@ -3,11 +3,12 @@
     import { TextHintVariant } from 'shared/components/enums'
     import { getEnabledNetworkFromFeatureFlags } from '@core/network'
     import { NetworkId } from '@core/network/enums'
+    import { openUrlInBrowser } from '@core/app'
 
     const NETWORK_ID = getEnabledNetworkFromFeatureFlags()
 
     function onLinkClick(): void {
-        window.open('https://chrome.google.com/webstore/detail/iota-wallet/iidjkmdceolghepehaaddojmnjnkkija', '_blank')
+        openUrlInBrowser('chromewebstore.google.com/detail/iota-wallet/iidjkmdceolghepehaaddojmnjnkkija')
     }
 </script>
 

packages/desktop/components/popups/GetSeedPopup.svelte

@@ -11,12 +11,17 @@
         initialiseOnboardingProfile,
         initialiseProfileManagerFromOnboardingProfile,
         resetOnboardingProfile,
+        onboardingProfile,
     } from '@contexts/onboarding'
-    import { STRONGHOLD_VERSION } from '@core/stronghold'
     import { api, getProfileManager } from '@core/profile-manager'
     import { ProfileType } from '@core/profile'
-    import { getDefaultPersistedNetwork, NetworkId } from '@core/network'
-
+    import { getDefaultClientOptions, getDefaultPersistedNetwork, NetworkId } from '@core/network'
+    import { CLIENT_ERROR_REGEXES } from '@core/error/constants'
+    import { ClientError } from '@core/error/enums'
+    import { restoreBackup } from '@core/profile-manager/api'
+    import { StrongholdVersion } from '@core/stronghold/enums'
+    import { STRONGHOLD_VERSION } from '@core/stronghold'
+    import { showAppNotification } from '@auxiliary/notification'
     interface FileWithPath extends File {
         path?: string
     }
@@ -42,13 +47,19 @@
         setClipboard(seed)
     }
 
-    function openUnlockStrongholdPopup(): void {
+    function openUnlockStrongholdPopup(shouldMigrateStronghold: boolean): void {
         openPopup({
             id: PopupId.UnlockStronghold,
             props: {
                 returnPassword: true,
                 restoreBackupFromStronghold: true,
-                onSuccess: () => {
+                shouldMigrateStronghold,
+                onSuccess: async (password) => {
+                    if (!shouldMigrateStronghold) {
+                        updateOnboardingProfile({ strongholdPassword: password })
+                        await initialiseProfileManagerFromOnboardingProfile()
+                    }
+
                     openPopup({
                         id: PopupId.GetSeedPopup,
                         props: {
@@ -110,23 +121,54 @@
 
     async function extractSeedFromStrongholdFile(): Promise<void> {
         await initialiseOnboardingProfile(false, true)
+        const network = getDefaultPersistedNetwork(NetworkId.Iota)
+        const clientOptions = getDefaultClientOptions(NetworkId.Iota)
         validateBackupFile(importFileName)
         updateOnboardingProfile({
-            network: getDefaultPersistedNetwork(NetworkId.Iota),
+            network,
+            clientOptions,
             importFile,
             importFilePath,
             // TODO: we don't have a way to know the stronghold version of the backup file yet
             strongholdVersion: STRONGHOLD_VERSION,
             type: ProfileType.Software,
         })
+
         await initialiseProfileManagerFromOnboardingProfile()
-        openUnlockStrongholdPopup()
+
+        const _shouldMigrate = await shouldMigrate()
+        if (_shouldMigrate) {
+            updateOnboardingProfile({ strongholdVersion: StrongholdVersion.V2 })
+        }
+        openUnlockStrongholdPopup(_shouldMigrate)
     }
 
     async function getSeedFromSecretManager(): Promise<void> {
-        const managerId = await getProfileManager().id
-        const secretManager = await api.getSecretManager(managerId)
-        seed = await secretManager?.getSeed()
+        try {
+            const managerId = await getProfileManager().id
+            const secretManager = await api.getSecretManager(managerId)
+            seed = await secretManager?.getSeed()
+        } catch (err) {
+            showAppNotification({
+                type: 'error',
+                message: 'Seed backup was unsuccessful.',
+                subMessage: 'Please ensure your Stronghold file is valid and the password is correct.',
+            })
+            closePopup()
+            if (shouldResetOnboardingProfile) {
+                resetOnboardingProfile()
+            }
+            console.error(err)
+        }
+    }
+
+    async function shouldMigrate(): Promise<boolean> {
+        try {
+            await restoreBackup(importFilePath, '', $onboardingProfile.network.protocol.bech32Hrp)
+        } catch (err) {
+            const isMigrationRequired = CLIENT_ERROR_REGEXES[ClientError.MigrationRequired].test(err?.error)
+            return isMigrationRequired
+        }
     }
 
     if (!readFromFile) {

packages/desktop/components/popups/UnlockStrongholdPopup.svelte

@@ -3,12 +3,17 @@
     import { closePopup } from '@auxiliary/popup'
     import { localize } from '@core/i18n'
     import { unlockStronghold } from '@core/profile'
-    import { restoreBackupFromStrongholdFile } from '@contexts/onboarding'
+    import {
+        migrateStrongholdFromOnboardingProfile,
+        restoreBackupFromStrongholdFile,
+        StrongholdMigrationRequiredError,
+    } from '@contexts/onboarding'
     import { CLIENT_ERROR_REGEXES, ClientError } from '@core/error'
 
     export let subtitle: string = ''
     export let returnPassword = false
     export let restoreBackupFromStronghold = false
+    export let shouldMigrateStronghold: boolean = false
 
     export let onSuccess: (..._: any[]) => void = () => {}
     export let onCancelled: (..._: any[]) => void = () => {}
@@ -20,23 +25,39 @@
     async function onSubmit(): Promise<void> {
         try {
             isBusy = true
+            if (shouldMigrateStronghold) {
+                await migrateStrongholdFromOnboardingProfile(password)
+            }
+
             const response = restoreBackupFromStronghold
                 ? await restoreBackupFromStrongholdFile(password)
                 : await unlockStronghold(password)
             closePopup()
             onSuccess(returnPassword ? password : response)
         } catch (err) {
             if (err.message) {
-                error = localize(err.message)
+                handleErrorMessage(err.message)
             } else if (CLIENT_ERROR_REGEXES[ClientError.InvalidStrongholdPassword].test(err?.error)) {
                 error = localize('error.password.incorrect')
+            } else if (CLIENT_ERROR_REGEXES[ClientError.MigrationRequired].test(err?.error)) {
+                throw new StrongholdMigrationRequiredError()
             } else {
                 error = localize(err)
             }
         } finally {
             isBusy = false
         }
     }
+    function handleErrorMessage(message): void {
+        try {
+            const migrationError = JSON.parse(message).payload?.error
+            if (migrationError && CLIENT_ERROR_REGEXES[ClientError.StrongholdMigration].test(migrationError)) {
+                error = localize('error.password.incorrect')
+            } else error = localize(migrationError ?? message)
+        } catch {
+            error = localize(message)
+        }
+    }
 
     function onCancelClick(): void {
         closePopup()

packages/desktop/views/dashboard/Dashboard.svelte

@@ -10,10 +10,10 @@
         reflectLockedStronghold,
     } from '@core/profile'
     import { appRouter, dashboardRoute } from '@core/router'
-    import { Idle } from 'shared/components'
+    import { Idle, Link } from 'shared/components'
     import { stopPollingLedgerNanoStatus } from '@core/ledger'
     import { removeDisplayNotification, showAppNotification } from '@auxiliary/notification'
-    import { Platform } from '@core/app'
+    import { Platform, openUrlInBrowser } from '@core/app'
     import { Developer, Settings, Vesting, Collectibles, Governance, Wallet } from './'
     import { onDestroy, onMount } from 'svelte'
     import Sidebar from './Sidebar.svelte'
@@ -148,12 +148,14 @@
             <span class=" text-gray-800 dark:text-white max-w-lg"
                 >Please switch to the new IOTA Wallet for continued support and updates.
             </span>
-            <a
-                href="https://chromewebstore.google.com/detail/iota-wallet/iidjkmdceolghepehaaddojmnjnkkija"
-                target="_blank"
-                rel="noopener noreferrer"
-                class="text-blue-500 underline">Download here</a
+            <Link
+                on:click={() =>
+                    openUrlInBrowser(
+                        'https://chromewebstore.google.com/detail/iota-wallet/iidjkmdceolghepehaaddojmnjnkkija'
+                    )}
             >
+                Download here
+            </Link>
         </div>
     {/if}
     <TopNavigation />

packages/shared/components/modals/InitProfileActionsModal.svelte

@@ -10,6 +10,7 @@
     import { MenuItem, Modal } from 'shared/components'
     import { PopupId, openPopup } from '@auxiliary/popup'
     import { profileManager } from '@core/profile-manager/stores'
+    import { isLatestStrongholdVersion } from '@core/app'
 
     export let modal: Modal | undefined
 
@@ -40,6 +41,14 @@
     }
 
     async function backupSeed(): Promise<void> {
+        if (!isLatestStrongholdVersion($activeProfile?.strongholdVersion)) {
+            showAppNotification({
+                type: 'error',
+                message:
+                    'The selected profile needs migration. Please locate your stronghold file and use the drag-and-drop flow located in the Electron menu > Backup Seed.',
+            })
+            return
+        }
         if (!$profileManager) {
             const profileManagerOptions = await buildProfileManagerOptionsFromProfileData($activeProfile)
             const { storagePath, coinType, clientOptions, secretManager: secretManagerType } = profileManagerOptions

packages/shared/lib/contexts/onboarding/actions/initialiseProfileManagerFromOnboardingProfile.ts

@@ -2,6 +2,7 @@ import { get } from 'svelte/store'
 
 import {
     buildProfileManagerOptionsFromProfileData,
+    getSecretManagerFromProfileType,
     initialiseProfileManager,
     profileManager,
 } from '@core/profile-manager'
@@ -21,8 +22,9 @@ export async function initialiseProfileManagerFromOnboardingProfile(checkForExis
     }
 
     const profileManagerOptions = await buildProfileManagerOptionsFromProfileData(get(onboardingProfile))
-    const { storagePath, coinType, clientOptions, secretManager } = profileManagerOptions
-    const { id } = get(onboardingProfile)
+    const { storagePath, coinType, clientOptions } = profileManagerOptions
+    const { id, strongholdPassword, type } = get(onboardingProfile)
+    const secretManager = getSecretManagerFromProfileType(type, storagePath, strongholdPassword)
     const manager = await initialiseProfileManager(storagePath, coinType, clientOptions, secretManager, id)
     profileManager.set(manager)
     updateOnboardingProfile({ hasInitialisedProfileManager: true })

packages/shared/lib/core/error/constants/error-regex.constant.ts

@@ -2,6 +2,8 @@ import { ClientError, IotaClientError } from '../enums'
 
 export const CLIENT_ERROR_REGEXES = {
     [ClientError.InvalidStrongholdPassword]: /`invalid stronghold password`/,
+    [ClientError.StrongholdMigration]:
+        /stronghold migration error: failed to decrypt snapshot: incorrect password or corrupt data/,
     [ClientError.MigrationRequired]: /`unsupported snapshot version, expected \d*, found \d*, migration required`/,
     [ClientError.NoSyncedNode]: /`No synced node available`/,
     [ClientError.InsufficientAmount]: /`insufficient amount: found \d*, required \d*`/,

packages/shared/lib/core/error/enums/client-error.enum.ts

@@ -1,6 +1,7 @@
 export enum ClientError {
     InvalidStrongholdPassword = 'invalidStrongholdPassword',
     MigrationRequired = 'migrationRequired',
+    StrongholdMigration = 'strongHoldMigration',
     NoSyncedNode = 'noSyncedNode',
     NotEnoughFundsToClaim = 'notEnoughFundsToClaim',
     InsufficientAmount = 'insufficientAmount',

packages/shared/lib/core/profile-manager/utils/getSecretManagerFromProfileType.ts

@@ -3,9 +3,13 @@ import { SecretManagerType } from '@iota/sdk/out/types'
 import { USE_LEDGER_SIMULATOR } from '@core/ledger'
 import { ProfileType } from '@core/profile'
 
-export function getSecretManagerFromProfileType(type: ProfileType, storagePath?: string): SecretManagerType {
+export function getSecretManagerFromProfileType(
+    type: ProfileType,
+    storagePath?: string,
+    password?: string
+): SecretManagerType {
     const strongholdSecretManager = {
-        stronghold: { snapshotPath: `${storagePath}/wallet.stronghold` },
+        stronghold: { snapshotPath: `${storagePath}/wallet.stronghold`, password },
     }
     const ledgerSecretManager = {
         ledgerNano: USE_LEDGER_SIMULATOR,