feature(@desktop/keycard): migrate an exsiting account from Keycard t…

…o Status Desktop

Fixes: #7030

src/app/modules/main/profile_section/keycard/module.nim

@@ -128,7 +128,10 @@ method runImportOrRestoreViaSeedPhrasePopup*(self: Module) =
   self.keycardSharedModule.runFlow(keycard_shared_module.FlowType.SetupNewKeycardOldSeedPhrase)
 
 method runImportFromKeycardToAppPopup*(self: Module) =
-  info "TODO: Import from Keycard to Status Desktop..."
+  self.createSharedKeycardModule()
+  if self.keycardSharedModule.isNil:
+    return
+  self.keycardSharedModule.runFlow(keycard_shared_module.FlowType.ImportFromKeycard)
 
 method runUnlockKeycardPopupForKeycardWithUid*(self: Module, keyUid: string) =
   self.createSharedKeycardModule()

src/app/modules/shared_modules/keycard_popup/controller.nim

@@ -2,6 +2,8 @@ import chronicles, strutils, os, sequtils, sugar
 import uuids
 import io_interface
 
+import ../../../global/app_sections_config as conf
+import ../../../global/app_signals
 import ../../../global/global_singleton
 import ../../../core/signals/types
 import ../../../core/eventemitter
@@ -52,6 +54,7 @@ type
     tmpKeycardUid: string
     tmpAddingMigratedKeypairSuccess: bool
     tmpConvertingProfileSuccess: bool
+    tmpKeycardImportCardMetadata: CardMetadata
     tmpKeycardCopyCardMetadata: CardMetadata
     tmpKeycardCopyPin: string
     tmpKeycardCopyDestinationKeycardUid: string
@@ -159,6 +162,10 @@ proc init*(self: Controller) =
     self.delegate.onSecondaryActionClicked()
   self.connectionIds.add(handlerId)
 
+proc switchToWalletSection*(self: Controller) =
+  let data = ActiveSectionChatArgs(sectionId: conf.WALLET_SECTION_ID)
+  self.events.emit(SIGNAL_MAKE_SECTION_CHAT_ACTIVE, data)
+
 proc getKeycardData*(self: Controller): string =
   return self.delegate.getKeycardData()
 
@@ -183,6 +190,9 @@ proc prepareKeyPairForProcessing*(self: Controller, keyUid: string) =
 proc getKeyPairForProcessing*(self: Controller): KeyPairItem =
   return self.delegate.getKeyPairForProcessing()
 
+proc getKeyPairHelper*(self: Controller): KeyPairItem =
+  return self.delegate.getKeyPairHelper()
+
 proc setPin*(self: Controller, value: string) =
   self.tmpPin = value
 
@@ -361,6 +371,13 @@ proc setMetadataForKeycardCopy*(self: Controller, cardMetadata: CardMetadata) =
   self.tmpKeycardCopyCardMetadata = cardMetadata
   self.setMetadataFromKeycard(cardMetadata)
 
+proc getMetadataForKeycardImport*(self: Controller): CardMetadata =
+  return self.tmpKeycardImportCardMetadata
+
+proc setMetadataForKeycardImport*(self: Controller, cardMetadata: CardMetadata) =
+  self.tmpKeycardImportCardMetadata = cardMetadata
+  self.delegate.updateKeyPairHelper(cardMetadata)
+
 proc setPinForKeycardCopy*(self: Controller, value: string) =
   self.tmpKeycardCopyPin = value
 
@@ -393,11 +410,11 @@ proc runGetAppInfoFlow*(self: Controller, factoryReset = false) =
   self.cancelCurrentFlow()
   self.keycardService.startGetAppInfoFlow(factoryReset)
 
-proc runGetMetadataFlow*(self: Controller, resolveAddress = false) =
+proc runGetMetadataFlow*(self: Controller, resolveAddress = false, exportMasterAddr = false) =
   if not serviceApplicable(self.keycardService):
     return
   self.cancelCurrentFlow()
-  self.keycardService.startGetMetadataFlow(resolveAddress)
+  self.keycardService.startGetMetadataFlow(resolveAddress, exportMasterAddr)
 
 proc runChangePinFlow*(self: Controller) =
   if not serviceApplicable(self.keycardService):

src/app/modules/shared_modules/keycard_popup/internal/enter_pin_state.nim

@@ -13,7 +13,8 @@ method getNextPrimaryState*(self: EnterPinState, controller: Controller): State
     self.flowType == FlowType.FactoryReset or
     self.flowType == FlowType.SetupNewKeycard or
     self.flowType == FlowType.SetupNewKeycardNewSeedPhrase or
-    self.flowType == FlowType.SetupNewKeycardOldSeedPhrase:
+    self.flowType == FlowType.SetupNewKeycardOldSeedPhrase or
+    self.flowType == FlowType.ImportFromKeycard:
       return createState(StateType.FactoryResetConfirmation, self.flowType, self)
   if self.flowType == FlowType.CreateCopyOfAKeycard:
     if isPredefinedKeycardDataFlagSet(controller.getKeycardData(), PredefinedKeycardData.CopyFromAKeycardPartDone):
@@ -26,6 +27,7 @@ method executePreSecondaryStateCommand*(self: EnterPinState, controller: Control
   if self.flowType == FlowType.SetupNewKeycard or
     self.flowType == FlowType.SetupNewKeycardNewSeedPhrase or
     self.flowType == FlowType.SetupNewKeycardOldSeedPhrase or
+    self.flowType == FlowType.ImportFromKeycard or
     self.flowType == FlowType.FactoryReset or
     self.flowType == FlowType.DisplayKeycardContent or
     self.flowType == FlowType.RenameKeycard or
@@ -44,6 +46,7 @@ method executeCancelCommand*(self: EnterPinState, controller: Controller) =
     self.flowType == FlowType.SetupNewKeycard or
     self.flowType == FlowType.SetupNewKeycardNewSeedPhrase or
     self.flowType == FlowType.SetupNewKeycardOldSeedPhrase or
+    self.flowType == FlowType.ImportFromKeycard or
     self.flowType == FlowType.Authentication or
     self.flowType == FlowType.DisplayKeycardContent or
     self.flowType == FlowType.RenameKeycard or
@@ -142,6 +145,43 @@ method resolveKeycardNextState*(self: EnterPinState, keycardFlowType: string, ke
     if keycardFlowType == ResponseTypeValueKeycardFlowResult:
       controller.setMetadataFromKeycard(keycardEvent.cardMetadata)
       return createState(StateType.PinVerified, self.flowType, nil)
+  if self.flowType == FlowType.ImportFromKeycard:
+    if keycardFlowType == ResponseTypeValueEnterPIN and 
+      keycardEvent.error.len > 0 and
+      keycardEvent.error == ErrorPIN:
+      controller.setRemainingAttempts(keycardEvent.pinRetries)
+      if keycardEvent.pinRetries > 0:
+        return createState(StateType.WrongPin, self.flowType, nil)
+      controller.setKeycardData(updatePredefinedKeycardData(controller.getKeycardData(), PredefinedKeycardData.DisableSeedPhraseForUnlock, add = true))
+      return createState(StateType.MaxPinRetriesReached, self.flowType, nil)
+    if keycardFlowType == ResponseTypeValueEnterPIN and 
+      keycardEvent.error.len == 0:
+        controller.setKeycardData(updatePredefinedKeycardData(controller.getKeycardData(), PredefinedKeycardData.DisableSeedPhraseForUnlock, add = true))
+        return createState(StateType.MaxPinRetriesReached, self.flowType, nil)
+    if keycardFlowType == ResponseTypeValueEnterPUK and 
+      keycardEvent.error.len == 0:
+        if keycardEvent.pinRetries == 0 and keycardEvent.pukRetries > 0:
+          controller.setKeycardData(updatePredefinedKeycardData(controller.getKeycardData(), PredefinedKeycardData.DisableSeedPhraseForUnlock, add = true))
+          return createState(StateType.MaxPinRetriesReached, self.flowType, nil)
+    if keycardFlowType == ResponseTypeValueKeycardFlowResult:
+      controller.setKeycardUid(keycardEvent.instanceUID)
+      controller.setMetadataForKeycardImport(keycardEvent.cardMetadata)
+      let accountItem = controller.getKeyPairHelper().getAccountsModel().getItemAtIndex(0)
+      if accountItem.isNil:
+        # should never be here (if keycard doesn't contain metadata we should not be able to proceed with this flow)
+        return createState(StateType.ImportingFromKeycardFailure, self.flowType, nil)
+      var item = newKeyPairItem(keyUid = keycardEvent.keyUid)
+      item.setDerivedFrom(keycardEvent.masterKeyAddress)
+      item.setName(keycardEvent.cardMetadata.name)
+      item.setIcon("keycard")
+      item.setPairType(KeyPairType.SeedImport.int)
+      item.addAccount(newKeyPairAccountItem(name = "", 
+        path = accountItem.getPath(), 
+        address = accountItem.getAddress(),
+        pubKey = accountItem.getPubKey()
+      )) # name and other params will be set by the user during the flow
+      controller.setKeyPairForProcessing(item)
+      return createState(StateType.PinVerified, self.flowType, nil)
   if self.flowType == FlowType.Authentication:
     if keycardFlowType == ResponseTypeValueEnterPIN and 
       keycardEvent.error.len > 0 and

src/app/modules/shared_modules/keycard_popup/internal/importing_from_keycard_failure_state.nim

@@ -0,0 +1,17 @@
+type
+  ImportingFromKeycardFailureState* = ref object of State
+
+proc newImportingFromKeycardFailureState*(flowType: FlowType, backState: State): ImportingFromKeycardFailureState =
+  result = ImportingFromKeycardFailureState()
+  result.setup(flowType, StateType.ImportingFromKeycardFailure, backState)
+
+proc delete*(self: ImportingFromKeycardFailureState) =
+  self.State.delete
+
+method executePrePrimaryStateCommand*(self: ImportingFromKeycardFailureState, controller: Controller) =
+  if self.flowType == FlowType.ImportFromKeycard:
+    controller.terminateCurrentFlow(lastStepInTheCurrentFlow = true)
+
+method executeCancelCommand*(self: ImportingFromKeycardFailureState, controller: Controller) =
+  if self.flowType == FlowType.ImportFromKeycard:
+    controller.terminateCurrentFlow(lastStepInTheCurrentFlow = true)

src/app/modules/shared_modules/keycard_popup/internal/importing_from_keycard_state.nim

@@ -0,0 +1,50 @@
+type
+  ImportingFromKeycardState* = ref object of State
+    paths: seq[string]
+    addresses: seq[string]
+
+proc newImportingFromKeycardState*(flowType: FlowType, backState: State): ImportingFromKeycardState =
+  result = ImportingFromKeycardState()
+  result.setup(flowType, StateType.ImportingFromKeycard, backState)
+
+proc delete*(self: ImportingFromKeycardState) =
+  self.State.delete
+
+proc addAccountsToWallet(self: ImportingFromKeycardState, controller: Controller): bool =
+  let kpForProcessing = controller.getKeyPairForProcessing()
+  let kpHelper = controller.getKeyPairHelper()
+  for account in kpForProcessing.getAccountsModel().getItems():
+    self.addresses.add(account.getAddress())
+    if not controller.addWalletAccount(name = account.getName(), 
+      address = account.getAddress(), 
+      path = account.getPath(), 
+      addressAccountIsDerivedFrom = kpForProcessing.getDerivedFrom(), 
+      publicKey = account.getPubKey(), 
+      keyUid = kpForProcessing.getKeyUid(), 
+      accountType = if account.getPath() == PATH_DEFAULT_WALLET: SEED else: GENERATED,
+      color = account.getColor(), 
+      emoji = account.getEmoji()):
+        return false
+  return true
+
+proc doMigration(self: ImportingFromKeycardState, controller: Controller) =
+  let kpForProcessing = controller.getKeyPairForProcessing()
+  var kpDto = KeyPairDto(keycardUid: controller.getKeycardUid(),
+    keycardName: kpForProcessing.getName(),
+    keycardLocked: false,
+    accountsAddresses: self.addresses,
+    keyUid: kpForProcessing.getKeyUid())
+  controller.addMigratedKeyPair(kpDto)
+
+method getNextPrimaryState*(self: ImportingFromKeycardState, controller: Controller): State =
+  if self.flowType == FlowType.ImportFromKeycard:
+    if not self.addAccountsToWallet(controller):
+      return createState(StateType.ImportingFromKeycardFailure, self.flowType, nil)
+    self.doMigration(controller)
+    return nil
+
+method getNextSecondaryState*(self: ImportingFromKeycardState, controller: Controller): State =
+  if self.flowType == FlowType.ImportFromKeycard:
+    if controller.getAddingMigratedKeypairSuccess():
+      return createState(StateType.ImportingFromKeycardSuccess, self.flowType, nil)
+    return createState(StateType.ImportingFromKeycardFailure, self.flowType, nil)

src/app/modules/shared_modules/keycard_popup/internal/importing_from_keycard_success_state.nim

@@ -0,0 +1,22 @@
+type
+  ImportingFromKeycardSuccessState* = ref object of State
+
+proc newImportingFromKeycardSuccessState*(flowType: FlowType, backState: State): ImportingFromKeycardSuccessState =
+  result = ImportingFromKeycardSuccessState()
+  result.setup(flowType, StateType.ImportingFromKeycardSuccess, backState)
+
+proc delete*(self: ImportingFromKeycardSuccessState) =
+  self.State.delete
+
+method executePrePrimaryStateCommand*(self: ImportingFromKeycardSuccessState, controller: Controller) =
+  if self.flowType == FlowType.ImportFromKeycard:
+    controller.terminateCurrentFlow(lastStepInTheCurrentFlow = true)
+
+method executePreSecondaryStateCommand*(self: ImportingFromKeycardSuccessState, controller: Controller) =
+  if self.flowType == FlowType.ImportFromKeycard:
+    controller.switchToWalletSection()
+    controller.terminateCurrentFlow(lastStepInTheCurrentFlow = true)
+
+method executeCancelCommand*(self: ImportingFromKeycardSuccessState, controller: Controller) =
+  if self.flowType == FlowType.ImportFromKeycard:
+    controller.terminateCurrentFlow(lastStepInTheCurrentFlow = true)

src/app/modules/shared_modules/keycard_popup/internal/insert_keycard_state.nim

@@ -18,6 +18,7 @@ method executeCancelCommand*(self: InsertKeycardState, controller: Controller) =
     self.flowType == FlowType.SetupNewKeycard or
     self.flowType == FlowType.SetupNewKeycardNewSeedPhrase or
     self.flowType == FlowType.SetupNewKeycardOldSeedPhrase or
+    self.flowType == FlowType.ImportFromKeycard or
     self.flowType == FlowType.Authentication or
     self.flowType == FlowType.UnlockKeycard or
     self.flowType == FlowType.DisplayKeycardContent or

src/app/modules/shared_modules/keycard_popup/internal/keycard_empty_metadata_state.nim

@@ -13,13 +13,15 @@ method executeCancelCommand*(self: KeycardEmptyMetadataState, controller: Contro
     self.flowType == FlowType.SetupNewKeycard or
     self.flowType == FlowType.SetupNewKeycardNewSeedPhrase or
     self.flowType == FlowType.SetupNewKeycardOldSeedPhrase or
+    self.flowType == FlowType.ImportFromKeycard or
     self.flowType == FlowType.DisplayKeycardContent or
     self.flowType == FlowType.RenameKeycard or
     self.flowType == FlowType.CreateCopyOfAKeycard:
       controller.terminateCurrentFlow(lastStepInTheCurrentFlow = false)
 
 method executePrePrimaryStateCommand*(self: KeycardEmptyMetadataState, controller: Controller) =
   if self.flowType == FlowType.DisplayKeycardContent or
+    self.flowType == FlowType.ImportFromKeycard or
     self.flowType == FlowType.RenameKeycard:
       controller.terminateCurrentFlow(lastStepInTheCurrentFlow = true)
   if self.flowType == FlowType.CreateCopyOfAKeycard:

src/app/modules/shared_modules/keycard_popup/internal/keycard_empty_state.nim

@@ -10,6 +10,7 @@ proc delete*(self: KeycardEmptyState) =
 
 method executePrePrimaryStateCommand*(self: KeycardEmptyState, controller: Controller) =
   if self.flowType == FlowType.FactoryReset or
+    self.flowType == FlowType.ImportFromKeycard or
     self.flowType == FlowType.Authentication or
     self.flowType == FlowType.UnlockKeycard or
     self.flowType == FlowType.DisplayKeycardContent or
@@ -22,6 +23,7 @@ method executePrePrimaryStateCommand*(self: KeycardEmptyState, controller: Contr
 
 method executeCancelCommand*(self: KeycardEmptyState, controller: Controller) =
   if self.flowType == FlowType.FactoryReset or
+    self.flowType == FlowType.ImportFromKeycard or
     self.flowType == FlowType.Authentication or
     self.flowType == FlowType.UnlockKeycard or
     self.flowType == FlowType.DisplayKeycardContent or

src/app/modules/shared_modules/keycard_popup/internal/keycard_inserted_state.nim

@@ -25,6 +25,7 @@ method executeCancelCommand*(self: KeycardInsertedState, controller: Controller)
     self.flowType == FlowType.SetupNewKeycard or
     self.flowType == FlowType.SetupNewKeycardNewSeedPhrase or
     self.flowType == FlowType.SetupNewKeycardOldSeedPhrase or
+    self.flowType == FlowType.ImportFromKeycard or
     self.flowType == FlowType.Authentication or
     self.flowType == FlowType.UnlockKeycard or
     self.flowType == FlowType.DisplayKeycardContent or

src/app/modules/shared_modules/keycard_popup/internal/keycard_metadata_display_state.nim

@@ -14,6 +14,8 @@ method getNextPrimaryState*(self: KeycardMetadataDisplayState, controller: Contr
     self.flowType == FlowType.SetupNewKeycardNewSeedPhrase or
     self.flowType == FlowType.SetupNewKeycardOldSeedPhrase:
       return createState(StateType.FactoryResetConfirmationDisplayMetadata, self.flowType, self)
+  if self.flowType == FlowType.ImportFromKeycard:
+    return createState(StateType.ManageKeycardAccounts, self.flowType, self)
   if self.flowType == FlowType.DisplayKeycardContent:
     controller.terminateCurrentFlow(lastStepInTheCurrentFlow = true)
   if self.flowType == FlowType.RenameKeycard:
@@ -33,6 +35,7 @@ method executeCancelCommand*(self: KeycardMetadataDisplayState, controller: Cont
     self.flowType == FlowType.SetupNewKeycard or
     self.flowType == FlowType.SetupNewKeycardNewSeedPhrase or
     self.flowType == FlowType.SetupNewKeycardOldSeedPhrase or
+    self.flowType == FlowType.ImportFromKeycard or
     self.flowType == FlowType.DisplayKeycardContent or
     self.flowType == FlowType.RenameKeycard or
     self.flowType == FlowType.CreateCopyOfAKeycard:

src/app/modules/shared_modules/keycard_popup/internal/manage_keycard_accounts_state.nim

@@ -15,6 +15,21 @@ method getNextPrimaryState*(self: ManageKeycardAccountsState, controller: Contro
     return createState(StateType.CreatingAccountNewSeedPhrase, self.flowType, nil)
   if self.flowType == FlowType.SetupNewKeycardOldSeedPhrase:
     return createState(StateType.CreatingAccountOldSeedPhrase, self.flowType, nil)
+  if self.flowType == FlowType.ImportFromKeycard:
+    let numOfProcessedAccounts = controller.getKeyPairForProcessing().getAccountsModel().getCount()
+    let totalNumOfAccountsToBeProcessed = controller.getKeyPairHelper().getAccountsModel().getCount()
+    if numOfProcessedAccounts < totalNumOfAccountsToBeProcessed:
+      let accountItem = controller.getKeyPairHelper().getAccountsModel().getItemAtIndex(numOfProcessedAccounts) # numOfProcessedAccounts is index of next acc which need to be processed
+      if accountItem.isNil:
+        # should never be here
+        return createState(StateType.ImportingFromKeycardFailure, self.flowType, nil)
+      controller.getKeyPairForProcessing().addAccount(newKeyPairAccountItem(name = "", 
+        path = accountItem.getPath(), 
+        address = accountItem.getAddress(),
+        pubKey = accountItem.getPubKey()
+      ))
+    elif numOfProcessedAccounts == totalNumOfAccountsToBeProcessed:
+      return createState(StateType.ImportingFromKeycard, self.flowType, nil)
 
 method executePreSecondaryStateCommand*(self: ManageKeycardAccountsState, controller: Controller) =
   if self.flowType == FlowType.SetupNewKeycardNewSeedPhrase or
@@ -23,5 +38,6 @@ method executePreSecondaryStateCommand*(self: ManageKeycardAccountsState, contro
 
 method executeCancelCommand*(self: ManageKeycardAccountsState, controller: Controller) =
   if self.flowType == FlowType.SetupNewKeycardNewSeedPhrase or
-    self.flowType == FlowType.SetupNewKeycardOldSeedPhrase:
+    self.flowType == FlowType.SetupNewKeycardOldSeedPhrase or
+    self.flowType == FlowType.ImportFromKeycard:
       controller.terminateCurrentFlow(lastStepInTheCurrentFlow = false)

src/app/modules/shared_modules/keycard_popup/internal/max_pairing_slots_reached_state.nim

@@ -14,7 +14,8 @@ method getNextPrimaryState*(self: MaxPairingSlotsReachedState, controller: Contr
     self.flowType == FlowType.SetupNewKeycardNewSeedPhrase or
     self.flowType == FlowType.SetupNewKeycardOldSeedPhrase:
       return createState(StateType.FactoryResetConfirmation, self.flowType, self)
-  if self.flowType == FlowType.Authentication or
+  if self.flowType == FlowType.ImportFromKeycard or
+    self.flowType == FlowType.Authentication or
     self.flowType == FlowType.DisplayKeycardContent or
     self.flowType == FlowType.RenameKeycard or
     self.flowType == FlowType.ChangeKeycardPin or
@@ -30,6 +31,7 @@ method executeCancelCommand*(self: MaxPairingSlotsReachedState, controller: Cont
     self.flowType == FlowType.SetupNewKeycard or
     self.flowType == FlowType.SetupNewKeycardNewSeedPhrase or
     self.flowType == FlowType.SetupNewKeycardOldSeedPhrase or
+    self.flowType == FlowType.ImportFromKeycard or
     self.flowType == FlowType.Authentication or
     self.flowType == FlowType.UnlockKeycard or
     self.flowType == FlowType.DisplayKeycardContent or