currencyCode -> tokenId followup fixes

CHANGELOG.md

@@ -2,6 +2,9 @@
 
 ## Unreleased
 
+- changed: Migrate ondisk transaction data keyed by `currencyCode` to `tokenId`
+- changed: Refactor Ethereum `EthereumNetwork.acquireUpdates` to allow partial status updates
+
 ## 4.67.0 (2025-12-09)
 
 - changed: Index internal wallet data with tokenIds

src/common/CurrencyEngine.ts

@@ -154,21 +154,18 @@ export class CurrencyEngine<
     // Sync in-memory decoy addresses with what core has saved
     this.subscribedAddresses = opts.subscribedAddresses ?? []
     this.transactionEvents = []
-    this.transactionList = {}
     this.transactionListDirty = false
     this.transactionsLoaded = false
-    this.txIdMap = {}
-    this.txIdList = {}
     this.walletInfo = walletInfo
     this.walletId = walletInfo.id
     this.currencyInfo = currencyInfo
     this.otherData = undefined
     this.minimumAddressBalance = '0'
 
     // Use empty string null tokenId
-    this.transactionList[''] = []
-    this.txIdMap[''] = {}
-    this.txIdList[''] = []
+    this.transactionList = { '': [] }
+    this.txIdMap = { '': {} }
+    this.txIdList = { '': [] }
 
     // Configure tokens:
     this.builtinTokens = builtinTokens
@@ -321,6 +318,51 @@ export class CurrencyEngine<
 
   protected setOtherData(raw: any): void {}
 
+  /**
+   * Migrates transaction data from currency code keys to tokenId keys, if necessary.
+   * Old format: keyed by currency codes (e.g., "ETH", "USDC")
+   * New format: keyed by tokenIds (e.g., "", "a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48")
+   */
+  private migrateCurrencyCodeToTokenId<T>(
+    data: Record<string, T> | undefined
+  ): Record<string, T> | undefined {
+    if (data == null) {
+      return data
+    }
+
+    // Check if migration is needed - if data already has empty string key, it's already migrated
+    if (data[''] != null) {
+      return data
+    }
+
+    const migrated: Record<string, T> = {}
+
+    for (const [currencyCode, value] of Object.entries(data)) {
+      let newKey: string
+
+      // Native currency maps to empty string
+      if (currencyCode === this.currencyInfo.currencyCode) {
+        newKey = ''
+      } else {
+        // Find tokenId in allTokensMap that matches this currency code
+        const tokenId = Object.keys(this.allTokensMap).find(
+          tid => this.allTokensMap[tid]?.currencyCode === currencyCode
+        )
+
+        if (tokenId != null) {
+          newKey = tokenId
+        } else {
+          // No matching token found
+          continue
+        }
+      }
+
+      migrated[newKey] = value
+    }
+
+    return migrated
+  }
+
   protected async loadTransactions(): Promise<void> {
     if (this.transactionsLoaded) {
       this.log('Transactions already loaded')
@@ -366,6 +408,31 @@ export class CurrencyEngine<
       }
     }
 
+    // Migrate old data from currency codes to tokenIds if needed
+    const needsMigration =
+      (txIdList != null &&
+        Object.keys(txIdList).length > 0 &&
+        txIdList[''] == null) ||
+      (txIdMap != null &&
+        Object.keys(txIdMap).length > 0 &&
+        txIdMap[''] == null) ||
+      (transactionList != null &&
+        Object.keys(transactionList).length > 0 &&
+        transactionList[''] == null)
+
+    if (needsMigration) {
+      this.log.warn(
+        'Migrating transaction data from currency codes to tokenIds'
+      )
+      txIdList = this.migrateCurrencyCodeToTokenId(txIdList) ?? this.txIdList
+      txIdMap = this.migrateCurrencyCodeToTokenId(txIdMap) ?? this.txIdMap
+      transactionList =
+        this.migrateCurrencyCodeToTokenId(transactionList) ??
+        this.transactionList
+      this.transactionListDirty = true
+      this.log.warn('Migration complete')
+    }
+
     let isEmptyTransactions = true
     for (const tid of Object.keys(this.transactionList)) {
       if (
@@ -838,7 +905,7 @@ export class CurrencyEngine<
       return
     }
 
-    const activeTokenIds = this.enabledTokenIds
+    const activeTokenIds = [null, ...this.enabledTokenIds]
     const perTokenSlice = 1 / activeTokenIds.length
     let totalStatus = 0
     let numComplete = 0

src/cosmos/engine/ThorchainEngine.ts

@@ -6,6 +6,7 @@ import { EdgeCurrencyEngineOptions } from 'edge-core-js/types'
 
 import { PluginEnvironment } from '../../common/innerPlugin'
 import { getRandomDelayMs } from '../../common/network'
+import { snooze } from '../../common/utils'
 import { CosmosTools } from '../CosmosTools'
 import {
   asCosmosWalletOtherData,
@@ -88,6 +89,8 @@ export class ThorchainEngine extends CosmosEngine {
           headers
         )
         if (!res.ok) {
+          // snooze in case we're rate-limited
+          await snooze(1000)
           const message = await res.text()
           throw new Error(message)
         }

src/ethereum/EthereumEngine.ts

@@ -530,21 +530,6 @@ export class EthereumEngine extends CurrencyEngine<
 
   setOtherData(raw: any): void {
     const otherData = asEthereumWalletOtherData(raw)
-
-    // Hack otherData. To be removed once local data stops using currency codes as keys
-    switch (this.currencyInfo.pluginId) {
-      case 'zksync': {
-        // The USDC.e token used to be called USDC so we need to
-        // force a resync of transaction history to avoid showing USDC
-        // transactions in the now USDC.e wallet
-        if (!otherData.zksyncForceResyncUSDC) {
-          this.walletLocalData.lastTransactionQueryHeight.USDC = 0
-          otherData.zksyncForceResyncUSDC = true
-          this.walletLocalDataDirty = true
-        }
-      }
-    }
-
     this.otherData = otherData
   }
 

src/ethereum/EthereumNetwork.ts

@@ -361,6 +361,8 @@ export class EthereumNetwork {
    * This function gets the balance and transaction updates from the network.
    */
   acquireUpdates = async (): Promise<void> => {
+    const updateFuncs = []
+
     // The engine supports token balances batch queries if an adapter provides
     // the functionality.
     const isFetchTokenBalancesSupported =
@@ -373,7 +375,7 @@ export class EthereumNetwork {
       // each token individually.
       isFetchTokenBalancesSupported
     ) {
-      await this.acquireTokenBalances()
+      updateFuncs.push(async () => await this.acquireTokenBalances())
     }
 
     const tokenIds: EdgeTokenId[] = [null, ...this.ethEngine.enabledTokenIds]
@@ -383,11 +385,24 @@ export class EthereumNetwork {
         // batch token balance queries.
         !isFetchTokenBalancesSupported
       ) {
-        await this.acquireTokenBalance(tokenId)
+        updateFuncs.push(async () => await this.acquireTokenBalance(tokenId))
       }
 
-      await this.acquireTxs(tokenId)
+      updateFuncs.push(async () => await this.acquireTxs(tokenId))
+    }
+
+    let firstError: Error | undefined
+    for (const func of updateFuncs) {
+      try {
+        await func()
+      } catch (error: unknown) {
+        if (firstError == null && error instanceof Error) {
+          firstError = error
+        }
+      }
     }
+
+    if (firstError != null) throw firstError
   }
 
   private isAnAdapterConnected(): boolean {
@@ -463,7 +478,6 @@ export class EthereumNetwork {
       )
       let highestTxBlockHeight = 0
       for (const [tokenId, tuple] of tokenTxs) {
-        if (tokenId == null) continue
         this.ethEngine.tokenCheckTransactionsStatus.set(tokenId, 1)
         for (const tx of tuple.edgeTransactions) {
           this.ethEngine.addTransaction(tokenId, tx)

src/ethereum/ethereumTypes.ts

@@ -288,9 +288,6 @@ export const asEthereumWalletOtherData = asObject({
   /** @deprecated use nextNonce and count the observed pending transactions instead */
   unconfirmedNextNonce: asMaybe(asString, '0'),
 
-  // hacks
-  zksyncForceResyncUSDC: asMaybe(asBoolean, false),
-
   /** Decoy addresses that are pending inclusion in subscribedAddresses */
   pendingDecoyAddresses: asMaybe(asArray(asDecoyAddress), () => [])
 })

src/ripple/rippleInfo.ts

@@ -77,11 +77,11 @@ export const builtinTokens: EdgeTokenMap = {
       }
     },
   'USD-rhub8VRN55s94qWKDv6jmDy1pUykJzF3wq': {
-    currencyCode: 'USD.gh',
+    currencyCode: 'USD',
     displayName: 'Gatehub USD',
     denominations: [
       {
-        name: 'USD.gh',
+        name: 'USD',
         multiplier: '1000000000000000000'
       }
     ],
@@ -91,11 +91,11 @@ export const builtinTokens: EdgeTokenMap = {
     }
   },
   'EUR-rhub8VRN55s94qWKDv6jmDy1pUykJzF3wq': {
-    currencyCode: 'EUR.gh',
+    currencyCode: 'EUR',
     displayName: 'Gatehub EUR',
     denominations: [
       {
-        name: 'EUR.gh',
+        name: 'EUR',
         multiplier: '1000000000000000000'
       }
     ],
@@ -105,11 +105,11 @@ export const builtinTokens: EdgeTokenMap = {
     }
   },
   'USD-rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B': {
-    currencyCode: 'USD.bs',
+    currencyCode: 'USD',
     displayName: 'Bitstamp USD',
     denominations: [
       {
-        name: 'USD.bs',
+        name: 'USD',
         multiplier: '1000000000000000000'
       }
     ],
@@ -119,11 +119,11 @@ export const builtinTokens: EdgeTokenMap = {
     }
   },
   'EUR-rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B': {
-    currencyCode: 'EUR.bs',
+    currencyCode: 'EUR',
     displayName: 'Bitstamp EUR',
     denominations: [
       {
-        name: 'EUR.bs',
+        name: 'EUR',
         multiplier: '1000000000000000000'
       }
     ],
@@ -133,11 +133,11 @@ export const builtinTokens: EdgeTokenMap = {
     }
   },
   'USD-rEn9eRkX25wfGPLysUMAvZ84jAzFNpT5fL': {
-    currencyCode: 'USD.st',
+    currencyCode: 'USD',
     displayName: 'Stably USD',
     denominations: [
       {
-        name: 'USD.st',
+        name: 'USD',
         multiplier: '1000000000000000000'
       }
     ],

src/zcash/ZcashEngine.ts

@@ -218,12 +218,11 @@ export class ZcashEngine extends CurrencyEngine<
   updateBalance(tokenId: EdgeTokenId, balance: string): void {
     const currentBalance = this.getBalance({ tokenId })
     if (currentBalance == null || !eq(balance, currentBalance)) {
-      this.updateBalance(tokenId, balance)
+      this.walletLocalData.totalBalances[''] = balance
       this.walletLocalDataDirty = true
       this.warn(`${tokenId}: token Address balance: ${balance}`)
       this.currencyEngineCallbacks.onTokenBalanceChanged(tokenId, balance)
     }
-    this.tokenCheckBalanceStatus.set(tokenId, 1)
   }
 
   isSynced(): boolean {