Merge pull request #5989 from EdgeApp/sam/migrate-fix-zano

fix: preserve imported token migrations

Author: samholmes

eslint.config.mjs

@@ -238,7 +238,6 @@ export default [
       'src/components/scenes/ConfirmScene.tsx',
       'src/components/scenes/CreateWalletAccountSelectScene.tsx',
       'src/components/scenes/CreateWalletAccountSetupScene.tsx',
-      'src/components/scenes/CreateWalletCompletionScene.tsx',
 
       'src/components/scenes/CurrencyNotificationScene.tsx',
       'src/components/scenes/DefaultFiatSettingScene.tsx',
@@ -288,8 +287,6 @@ export default [
 
       'src/components/scenes/SwapSettingsScene.tsx',
       'src/components/scenes/SwapSuccessScene.tsx',
-      'src/components/scenes/SweepPrivateKeyCalculateFeeScene.tsx',
-      'src/components/scenes/SweepPrivateKeyCompletionScene.tsx',
 
       'src/components/scenes/TransactionDetailsScene.tsx',
 

src/components/scenes/CreateWalletCompletionScene.tsx

@@ -252,23 +252,44 @@ const CreateWalletCompletionComponent: React.FC<Props> = props => {
   })
 
   const handleMigrate = useHandler(() => {
-    // Transform filtered items into the structure expected by the migration component
-    const migrateWalletList: MigrateWalletItem[] = newWalletItems.map(
-      createWallet => {
-        const { key, pluginId } = createWallet
-        const wallet = wallets.find(
-          wallet => wallet.currencyInfo.pluginId === pluginId
-        )
+    // Build migrate items from successfully created parent wallets, then attach
+    // selected tokens for the same plugin to that same wallet id.
+    const successfulNewWalletItems = newWalletItems.filter(
+      item => itemStatus[item.key] === 'complete'
+    )
+    const addedTokenKeys = new Set<string>()
+    const migrateWalletList: MigrateWalletItem[] = []
+
+    for (const createWallet of successfulNewWalletItems) {
+      const { key, pluginId, walletType } = createWallet
+      const wallet = wallets.find(
+        wallet => wallet.currencyInfo.pluginId === pluginId
+      )
+      const createWalletId = wallet?.id ?? ''
+      const displayName = walletNames[key]
+
+      migrateWalletList.push({
+        ...createWallet,
+        createWalletId,
+        displayName,
+        key,
+        type: 'create'
+      })
+
+      for (const tokenItem of newTokenItems) {
+        if (tokenItem.pluginId !== pluginId) continue
+        if (addedTokenKeys.has(tokenItem.key)) continue
+        addedTokenKeys.add(tokenItem.key)
 
-        return {
-          ...createWallet,
-          createWalletId: wallet == null ? '' : wallet.id,
-          displayName: walletNames[key],
-          key,
+        migrateWalletList.push({
+          ...tokenItem,
+          createWalletId,
+          displayName,
+          walletType,
           type: 'create'
-        }
+        })
       }
-    )
+    }
 
     // Navigate to the migration screen with the prepared list
     if (migrateWalletList.length > 0) {

src/components/scenes/MigrateWalletCalculateFeeScene.tsx

@@ -39,7 +39,11 @@ export interface MigrateWalletCalculateFeeParams {
 
 type Props = EdgeAppSceneProps<'migrateWalletCalculateFee'>
 
-type AssetRowState = string | Error
+type AssetRowState = string | Error | 'included'
+type MakeMaxSpendMethod = (params: {
+  tokenIds?: Array<string | null>
+  spendTargets: Array<{ publicAddress: string }>
+}) => Promise<EdgeTransaction>
 
 const MigrateWalletCalculateFeeComponent: React.FC<Props> = props => {
   const { navigation, route } = props
@@ -117,6 +121,14 @@ const MigrateWalletCalculateFeeComponent: React.FC<Props> = props => {
             />
           )
         }
+      } else if (fee === 'included') {
+        rightSide = (
+          <EdgeText
+            style={{ color: theme.secondaryText, fontSize: theme.rem(0.75) }}
+          >
+            {lstrings.string_included}
+          </EdgeText>
+        )
       } else {
         const fakeEdgeTransaction: EdgeTransaction = {
           blockHeight: 0,
@@ -222,73 +234,123 @@ const MigrateWalletCalculateFeeComponent: React.FC<Props> = props => {
         }, [])
 
       let successCount = 0
-      const walletPromises = []
+      const walletRoutines = []
       for (const bundle of bundledWalletAssets) {
         const wallet = currencyWallets[bundle[bundle.length - 1].createWalletId]
         const {
           currencyInfo: { pluginId }
         } = wallet
-
         let feeTotal = '0'
         const bundlesFeeTotals = new Map<string, AssetRowState>(
           bundle.map(item => [item.key, '0'])
         )
 
-        const assetPromises = bundle.map((asset, i) => {
-          return async () => {
-            const publicAddress =
-              SPECIAL_CURRENCY_INFO[pluginId].dummyPublicAddress ??
-              (await wallet.getReceiveAddress({ tokenId: null })).publicAddress
-            const spendInfo: EdgeSpendInfo = {
-              tokenId: asset.tokenId,
-              spendTargets: [{ publicAddress }],
-              networkFeeOption: 'standard'
-            }
-
-            try {
-              const maxAmount = await wallet.getMaxSpendable(spendInfo)
-              if (maxAmount === '0') {
-                throw new InsufficientFundsError({ tokenId: asset.tokenId })
-              }
-              const maxSpendInfo = {
-                ...spendInfo,
-                spendTargets: [{ publicAddress, nativeAmount: maxAmount }]
-              }
-              const edgeTransaction = await wallet.makeSpend(maxSpendInfo)
-              const txFee =
-                edgeTransaction.parentNetworkFee ?? edgeTransaction.networkFee
-              bundlesFeeTotals.set(asset.key, txFee)
-              feeTotal = add(feeTotal, txFee)
-
-              // While imperfect, sanity check that the total fee spent so far to send tokens + fee to send mainnet currency is under the total mainnet balance
-              if (
-                i === bundle.length - 1 &&
-                lt(wallet.balanceMap.get(null) ?? '0', feeTotal)
-              ) {
-                throw new InsufficientFundsError({
-                  tokenId: null,
-                  networkFee: feeTotal
+        let assetSpendRoutines: Array<() => Promise<void>>
+        if (
+          (wallet.otherMethods.makeMaxSpend as
+            | MakeMaxSpendMethod
+            | undefined) != null
+        ) {
+          assetSpendRoutines = [
+            async () => {
+              const publicAddress =
+                SPECIAL_CURRENCY_INFO[pluginId].dummyPublicAddress ??
+                (await wallet.getReceiveAddress({ tokenId: null }))
+                  .publicAddress
+
+              try {
+                const tokenIds = bundle.map(item => item.tokenId)
+                const edgeTransaction = await (
+                  wallet.otherMethods.makeMaxSpend as MakeMaxSpendMethod
+                )({
+                  tokenIds,
+                  spendTargets: [{ publicAddress }]
                 })
-              }
-            } catch (e: any) {
-              for (const key of bundlesFeeTotals.keys()) {
-                const insufficientFundsError = asMaybeInsufficientFundsError(e)
-                if (insufficientFundsError != null) {
-                  bundlesFeeTotals.set(key, e)
-                } else {
+                const txFee =
+                  edgeTransaction.parentNetworkFee ?? edgeTransaction.networkFee
+                for (const item of bundle) {
                   bundlesFeeTotals.set(
-                    key,
-                    Error(lstrings.migrate_unknown_error_fragment)
+                    item.key,
+                    item.tokenId == null ? txFee : 'included'
                   )
                 }
+              } catch (e: any) {
+                for (const key of bundlesFeeTotals.keys()) {
+                  const insufficientFundsError =
+                    asMaybeInsufficientFundsError(e)
+                  if (insufficientFundsError != null) {
+                    bundlesFeeTotals.set(key, e)
+                  } else {
+                    bundlesFeeTotals.set(
+                      key,
+                      Error(lstrings.migrate_unknown_error_fragment)
+                    )
+                  }
+                }
               }
             }
-          }
-        })
+          ]
+        } else {
+          // Create an array of async functions to call that will spend each
+          // asset in the bundle.
+          assetSpendRoutines = bundle.map((asset, i) => {
+            return async () => {
+              const publicAddress =
+                SPECIAL_CURRENCY_INFO[pluginId].dummyPublicAddress ??
+                (await wallet.getReceiveAddress({ tokenId: null }))
+                  .publicAddress
+              const spendInfo: EdgeSpendInfo = {
+                tokenId: asset.tokenId,
+                spendTargets: [{ publicAddress }],
+                networkFeeOption: 'standard'
+              }
+
+              try {
+                const maxAmount = await wallet.getMaxSpendable(spendInfo)
+                if (maxAmount === '0') {
+                  throw new InsufficientFundsError({ tokenId: asset.tokenId })
+                }
+                const maxSpendInfo = {
+                  ...spendInfo,
+                  spendTargets: [{ publicAddress, nativeAmount: maxAmount }]
+                }
+                const edgeTransaction = await wallet.makeSpend(maxSpendInfo)
+                const txFee =
+                  edgeTransaction.parentNetworkFee ?? edgeTransaction.networkFee
+                bundlesFeeTotals.set(asset.key, txFee)
+                feeTotal = add(feeTotal, txFee)
+
+                // While imperfect, sanity check that the total fee spent so far to send tokens + fee to send mainnet currency is under the total mainnet balance
+                if (
+                  i === bundle.length - 1 &&
+                  lt(wallet.balanceMap.get(null) ?? '0', feeTotal)
+                ) {
+                  throw new InsufficientFundsError({
+                    tokenId: null,
+                    networkFee: feeTotal
+                  })
+                }
+              } catch (e: any) {
+                for (const key of bundlesFeeTotals.keys()) {
+                  const insufficientFundsError =
+                    asMaybeInsufficientFundsError(e)
+                  if (insufficientFundsError != null) {
+                    bundlesFeeTotals.set(key, e)
+                  } else {
+                    bundlesFeeTotals.set(
+                      key,
+                      Error(lstrings.migrate_unknown_error_fragment)
+                    )
+                  }
+                }
+              }
+            }
+          })
+        }
 
-        walletPromises.push(async () => {
-          for (const promise of assetPromises) {
-            await promise()
+        walletRoutines.push(async () => {
+          for (const spendRoutine of assetSpendRoutines) {
+            await spendRoutine()
           }
 
           const success = [...bundlesFeeTotals.values()].some(
@@ -305,8 +367,8 @@ const MigrateWalletCalculateFeeComponent: React.FC<Props> = props => {
       }
 
       await Promise.all(
-        walletPromises.map(async promise => {
-          await promise()
+        walletRoutines.map(async routine => {
+          await routine()
         })
       )
 

src/components/scenes/MigrateWalletCompletionScene.tsx

@@ -41,6 +41,11 @@ interface Props extends EdgeAppSceneProps<'migrateWalletCompletion'> {}
 interface MigrateWalletTokenItem extends MigrateWalletItem {
   tokenId: string
 }
+type MakeMaxSpendMethod = (params: {
+  tokenIds?: Array<string | null>
+  spendTargets: Array<{ publicAddress: string }>
+  metadata?: EdgeSpendInfo['metadata']
+}) => Promise<EdgeTransaction>
 
 const MigrateWalletCompletionComponent: React.FC<Props> = props => {
   const { navigation, route } = props
@@ -181,6 +186,57 @@ const MigrateWalletCompletionComponent: React.FC<Props> = props => {
           ]
           await newWallet.changeEnabledTokenIds(tokenIdsToEnable)
 
+          if (
+            (oldWallet.otherMethods.makeMaxSpend as
+              | MakeMaxSpendMethod
+              | undefined) != null
+          ) {
+            try {
+              const tokenIds = bundle.map(item => item.tokenId)
+              const unsignedTx = await (
+                oldWallet.otherMethods.makeMaxSpend as MakeMaxSpendMethod
+              )({
+                tokenIds,
+                spendTargets: [{ publicAddress: newPublicAddress }],
+                metadata: {
+                  category: 'Transfer',
+                  name: newWalletName,
+                  notes: sprintf(
+                    lstrings.migrate_wallet_tx_notes,
+                    newWalletName
+                  )
+                }
+              })
+              const signedTx = await oldWallet.signTx(unsignedTx)
+              const broadcastedTx = await oldWallet.broadcastTx(signedTx)
+              await oldWallet.saveTx(broadcastedTx)
+
+              for (const item of bundle) {
+                handleItemStatus(item, 'complete')
+              }
+              const successfullyTransferredTokenIds = tokenIds.filter(
+                (id): id is string => id != null
+              )
+              await oldWallet.changeEnabledTokenIds(
+                tokenIdsToEnable.filter(
+                  tokenId => !successfullyTransferredTokenIds.includes(tokenId)
+                )
+              )
+
+              const { modalShown } = securityCheckedWallets[oldWalletId]
+              securityCheckedWallets[oldWalletId] = {
+                checked: true,
+                modalShown
+              }
+            } catch (e) {
+              showError(e)
+              for (const item of bundle) {
+                handleItemStatus(item, 'error')
+              }
+            }
+            return
+          }
+
           // Send tokens
           let feeTotal = '0'
           const hasError = false