From 21d28964939d7297f29728908df34f6e210c5b6e Mon Sep 17 00:00:00 2001 From: Satoshi Qazi Muhammed Date: Wed, 8 Jul 2026 11:33:54 -0700 Subject: [PATCH] fix: retry Tron balance polling on failure instead of permanently dying Real user on a fresh install reported TRX and USDT-TRC20 never appearing anywhere in the Tokens list (not "zero balance", genuinely absent - including from the multi-chain USDT chain picker). Traced the full pipeline; every layer up to and including TypeBasedAssetSourceRegistry, ChainRegistry, address derivation, and TronGridApi wiring was already correct. Root cause: pollingBalanceFlow() had no retry around fetch() - any single transient failure (DNS hiccup, timeout, momentary connectivity loss during app cold start) threw out of the `while(true)` loop, killing the flow permanently. The collector (FullSyncPaymentUpdater.syncAsset()) only logs and gives up on failure, it doesn't resubscribe. Since the asset's first balance write never happens, AssetCache never inserts a DB row for it, and every UI surface (main list, multi-chain picker, search) reads exclusively via an INNER JOIN that requires that row to exist - so the asset is invisible everywhere, permanently, with zero user-visible error. Swallow fetch() failures and retry on the next interval instead of letting them escape the loop - one bad poll no longer blackholes the asset for the rest of the app session. Also fixes a related but separate gap found while tracing this: RealSecretsMetaAccount.multiChainEncryptionIn() had no isTronBased branch (only isEthereumBased), unlike DefaultMetaAccount's hasAccountIn/accountIdIn which already handle Tron correctly. This didn't cause the missing-tokens bug, but would have broken "export account" (JSON key backup) for Tron - fixed by routing Tron through MultiChainEncryption.Ethereum, matching what RealTronTransactionService already does for actual transaction signing (same secp256k1 keypair). --- .../account/model/RealSecretsMetaAccount.kt | 6 +++++- .../balances/tronNative/TronBalancePolling.kt | 15 +++++++++++++-- 2 files changed, 18 insertions(+), 3 deletions(-) diff --git a/feature-account-impl/src/main/java/io/novafoundation/nova/feature_account_impl/domain/account/model/RealSecretsMetaAccount.kt b/feature-account-impl/src/main/java/io/novafoundation/nova/feature_account_impl/domain/account/model/RealSecretsMetaAccount.kt index 7b88a202..57852a55 100644 --- a/feature-account-impl/src/main/java/io/novafoundation/nova/feature_account_impl/domain/account/model/RealSecretsMetaAccount.kt +++ b/feature-account-impl/src/main/java/io/novafoundation/nova/feature_account_impl/domain/account/model/RealSecretsMetaAccount.kt @@ -49,7 +49,9 @@ class RealSecretsMetaAccount( hasChainAccountIn(chain.id) -> { val cryptoType = chainAccounts.getValue(chain.id).cryptoType ?: return null - if (chain.isEthereumBased) { + // Tron reuses the same secp256k1 keypair/signing as Ethereum - see + // RealTronTransactionService's use of Signer.sign(MultiChainEncryption.Ethereum, ...). + if (chain.isEthereumBased || chain.isTronBased) { MultiChainEncryption.Ethereum } else { MultiChainEncryption.substrateFrom(cryptoType) @@ -58,6 +60,8 @@ class RealSecretsMetaAccount( chain.isEthereumBased -> MultiChainEncryption.Ethereum + chain.isTronBased -> MultiChainEncryption.Ethereum + else -> substrateCryptoType?.let(MultiChainEncryption.Companion::substrateFrom) } } diff --git a/feature-wallet-impl/src/main/java/io/novafoundation/nova/feature_wallet_impl/data/network/blockchain/assets/balances/tronNative/TronBalancePolling.kt b/feature-wallet-impl/src/main/java/io/novafoundation/nova/feature_wallet_impl/data/network/blockchain/assets/balances/tronNative/TronBalancePolling.kt index e1b61ddd..81f5a5d9 100644 --- a/feature-wallet-impl/src/main/java/io/novafoundation/nova/feature_wallet_impl/data/network/blockchain/assets/balances/tronNative/TronBalancePolling.kt +++ b/feature-wallet-impl/src/main/java/io/novafoundation/nova/feature_wallet_impl/data/network/blockchain/assets/balances/tronNative/TronBalancePolling.kt @@ -1,17 +1,26 @@ package io.novafoundation.nova.feature_wallet_impl.data.network.blockchain.assets.balances.tronNative +import android.util.Log import io.novafoundation.nova.feature_wallet_api.data.network.blockhain.types.Balance import kotlinx.coroutines.delay import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.flow private const val TRON_BALANCE_POLLING_INTERVAL_MS = 30_000L +private const val LOG_TAG = "TronBalancePolling" /** * TronGrid is a plain REST API with no push/subscription mechanism (unlike Ethereum nodes, which expose a * `newHeads`-style websocket subscription EVM balance sync piggybacks on). So balance updates for Tron-based * assets are polled instead of pushed: fetch immediately, then re-fetch on an interval, only emitting when the * balance actually changed. + * + * A failed fetch() must not escape this loop: any uncaught exception here cancels the whole flow permanently + * (the collector - FullSyncPaymentUpdater - only logs and gives up, it doesn't resubscribe), which meant a + * single transient failure (DNS hiccup, timeout, momentary connectivity loss during app cold start) could + * silently and permanently blackhole a Tron asset - no balance write ever happens, so it never even gets a row + * in the local DB and disappears from every UI surface with no visible error. Swallow and retry next interval + * instead. */ internal fun pollingBalanceFlow( intervalMs: Long = TRON_BALANCE_POLLING_INTERVAL_MS, @@ -20,9 +29,11 @@ internal fun pollingBalanceFlow( var lastEmitted: Balance? = null while (true) { - val latest = fetch() + val latest = runCatching { fetch() } + .onFailure { Log.e(LOG_TAG, "Tron balance fetch failed, will retry in ${intervalMs}ms", it) } + .getOrNull() - if (latest != lastEmitted) { + if (latest != null && latest != lastEmitted) { lastEmitted = latest emit(latest) }