## Summary After a UTXO daemon (BTC/BCH/LTC/DOGE) is restored from a snapshot, the Bifrost UTXO client reports **false insolvency** for asgard vaults: `GetAccount` returns a `0` wallet balance for vault addresses that actually hold funds, so the node emits insolvency `MsgSolvency` reports and accrues `failed_observe_solvency` slash points. ## Impact - The affected node is slashed continuously (`failed_observe_solvency`, one chain per reporting cadence) with no refund, because the report never reaches consensus. - More seriously: a node confidently reporting vault insolvency while its own wallet is unsynced **pollutes network solvency consensus** — and this surfaces precisely during incident/hack recovery, when solvency signal matters most. - Snapshot restore is the *recommended* fast-sync path, so this is not an edge case. ## Affected code - `bifrost/pkg/chainclients/utxo/client.go` — `GetAccount()` reads balance via `ListUnspent(addr)`, which only returns UTXOs for wallet addresses imported **and rescanned**. - `bifrost/pkg/chainclients/utxo/rpc/rpc.go` — `ImportAddress()` calls `importaddress addr "" false` (**rescan=false**). The rescan-enabled variant `ImportAddressRescan()` (`rescan=true`) exists but **has no callers anywhere in the codebase** (dead code). - `bifrost/pkg/chainclients/utxo/client.go` — `ReportSolvency()` / `runners.IsVaultSolvent()` declare insolvency whenever wallet balance < asgard-recorded balance. ## Root cause The design assumes Bifrost is always watching a vault address **before** it is funded (normal churn: import new vault address → migration tx arrives in a later block → the already-watching wallet catches it live, no rescan needed). That assumption breaks whenever the daemon's chainstate is **ahead** of when the address was imported: - snapshot restore (chainstate already contains the vault UTXOs), or - node offline / catching up across a churn boundary. With `rescan=false`, the wallet never looks back, so `ListUnspent` returns `0` for those pre-existing UTXOs indefinitely. There is no reconciliation or self-heal. ## Reproduction 1. Let an asgard vault accumulate UTXOs on a UTXO chain. 2. Restore that chain's daemon from a snapshot taken after those UTXOs exist (or have Bifrost import the vault address after the daemon is already synced past funding). 3. Bifrost imports the vault address with `rescan=false`. 4. `GetAccount` → `ListUnspent` returns `0` → node reports insolvency every cadence (BTC/BCH every block, LTC every 5, DOGE every 10). ## Evidence (observed on mainnet) "insolvency detected" chain=DOGE asgard_amount=368400366184738 wallet_amount=0 gap=368400366184738 "insolvency detected" chain=BTC asgard_amount=5706773277 wallet_amount=0 gap=5706773277 "reporting solvency" chain=BTC coins="0 BTC.BTC" solvent=false `wallet_amount=0` for **every** asgard vault across all four UTXO chains on the affected node, while the rest of the network reports the vaults solvent. A manual `importaddress <vault_addr> "" false` + `rescanblockchain <vault_creation_height>` (or `importaddress ... true` on Dogecoin's older Core, which lacks `rescanblockchain`) repopulates the balances and the false reports stop. ## Why current logic can't recover - No call site ever triggers a rescan (`ImportAddressRescan` is unused), so the wallet never self-corrects. - `ReportSolvency` already has the thornode-recorded vault balance available, but emits insolvency without sanity-checking its own wallet state first. ## Suggested direction (defer to maintainers) Distinguish "my wallet is unsynced" from "the vault is genuinely insolvent" before reporting — e.g. if wallet balance is `0` for a vault thornode records as funded (or all vaults on a chain read `0`), trigger a bounded rescan and re-read before emitting an insolvency `MsgSolvency`. A genuine insolvency survives the rescan; a desync is corrected. (Note: Dogecoin Core lacks `rescanblockchain`, so any rescan helper needs an `importaddress ... rescan=true` fallback there.) ## Environment - THORNode: mainnet (v3) - Chains affected: BTC, BCH, LTC, DOGE (UTXO clients) - Trigger: UTXO daemon snapshot restore