fix(stores,stores-eth): address parallel codex review findings

Convergent findings from 4 parallel review rounds:

- Thirdparty Child's imperative fetch() / waitFreshResponse / waitResponse
  now evaluate Alchemy coverage directly and force-register to the batch
  parent when the contract is missing, so non-reactive refresh paths
  (post-tx refresh, explicit fetch) actually exercise the fallback
  instead of resolving after Alchemy only.
- BatchParent.getError now reads chunk ownership from a snapshot taken
  at rebuild time instead of recomputing index from the live refcount
  ordering, eliminating misattribution during the debounce window.
- Child.error suppresses parent.error while batch fallback is still
  loading (no data, no batch error yet) so consumers stay in the
  loading state rather than warning on a transient Alchemy failure.
- ObservableJsonRpcBatchQuery synthesizes a per-request error for any
  requested id missing from the batch response, preventing permanent
  loading on partial/dropped server responses.
- Child.waitFreshResponse / waitResponse now return the effective
  response object, matching the existing query interface contract.

Author: piatoss3612

packages/stores-eth/src/queries/erc20-balance-batch.ts

@@ -21,6 +21,12 @@ export class ObservableQueryEthereumERC20BalancesBatchParent {
   @observable.ref
   protected lastBuiltKey = "";
 
+  // Snapshot of contract → batchQueries index at rebuild time, so getError
+  // doesn't misattribute chunk ownership during debounce transitions when
+  // the live refcount no longer matches the current batchQueries layout.
+  @observable.ref
+  protected chunkIndex: Map<string, number> = new Map();
+
   constructor(
     protected readonly sharedContext: QuerySharedContext,
     protected readonly chainId: string,
@@ -70,14 +76,13 @@ export class ObservableQueryEthereumERC20BalancesBatchParent {
   }
 
   // Per-contract error: surface only the error of the chunk that owns this
-  // contract, plus any per-request error the batch returned for it. A failing
-  // chunk no longer contaminates siblings in other chunks.
+  // contract (plus its per-request error if any). Looks up chunk ownership
+  // from the snapshot taken at rebuild time to avoid misattribution during
+  // debounced refcount transitions.
   getError(contract: string): QueryError<unknown> | undefined {
     const key = contract.toLowerCase();
-    const sortedKeys = Array.from(this.refcount.keys()).sort();
-    const idx = sortedKeys.indexOf(key);
-    if (idx === -1) return undefined;
-    const chunkIdx = Math.floor(idx / BATCH_CHUNK_SIZE);
+    const chunkIdx = this.chunkIndex.get(key);
+    if (chunkIdx === undefined) return undefined;
     const q = this.batchQueries[chunkIdx];
     if (!q) return undefined;
     if (q.error) return q.error;
@@ -109,6 +114,7 @@ export class ObservableQueryEthereumERC20BalancesBatchParent {
       runInAction(() => {
         this.batchQueries = [];
         this.lastBuiltKey = key;
+        this.chunkIndex = new Map();
       });
       return;
     }
@@ -118,6 +124,7 @@ export class ObservableQueryEthereumERC20BalancesBatchParent {
       runInAction(() => {
         this.batchQueries = [];
         this.lastBuiltKey = key;
+        this.chunkIndex = new Map();
       });
       return;
     }
@@ -132,6 +139,11 @@ export class ObservableQueryEthereumERC20BalancesBatchParent {
       ]),
     });
 
+    const nextChunkIndex = new Map<string, number>();
+    chunks.forEach((chunk, idx) => {
+      for (const c of chunk) nextChunkIndex.set(c, idx);
+    });
+
     runInAction(() => {
       this.batchQueries = chunks.map((chunk) => {
         const requests: JsonRpcBatchRequest[] = chunk.map((c) => ({
@@ -147,6 +159,7 @@ export class ObservableQueryEthereumERC20BalancesBatchParent {
         );
       });
       this.lastBuiltKey = key;
+      this.chunkIndex = nextChunkIndex;
     });
   }
 

packages/stores-eth/src/queries/erc20-balance.ts

@@ -129,7 +129,7 @@ export class ObservableQueryEthereumERC20BalanceImpl
     Readonly<QueryResponse<unknown>> | undefined
   > {
     await this.ensureFetched();
-    return undefined;
+    return this.response;
   }
 
   async waitResponse(): Promise<Readonly<QueryResponse<unknown>> | undefined> {

packages/stores-eth/src/queries/erc20-balances.ts

@@ -228,18 +228,20 @@ export class ObservableQueryThirdpartyERC20BalancesImpl
       .forceFindCurrency(denom);
   }
 
+  @computed
   @computed
   get error(): Readonly<QueryError<unknown>> | undefined {
     if (this.isInBatch) {
       const contract = this.denomHelper.contractAddress;
       const batchErr = this.parent.batchParent.getError(contract);
       if (batchErr) return batchErr;
-      // Once batch has valid data, an Alchemy error is no longer meaningful —
-      // the fallback successfully provided the balance.
+      // Batch has valid data — Alchemy's earlier error no longer matters.
       if (this.parent.batchParent.getBalance(contract) !== undefined) {
         return undefined;
       }
-      return this.parent.error;
+      // Batch still loading — stay in loading state, suppress parent.error so
+      // consumers don't prematurely warn before the fallback resolves.
+      return undefined;
     }
     return this.parent.error;
   }
@@ -307,31 +309,37 @@ export class ObservableQueryThirdpartyERC20BalancesImpl
       );
     }
     const alchemyFetch = this.parent.duplicatedFetchResolver;
-    return alchemyFetch.then(async () => {
-      // `isInBatch` flips only after Alchemy responds and the reaction runs,
-      // so check after awaiting Alchemy to include fallback refreshes.
-      if (this.isInBatch) {
-        await this.parent.batchParent.waitFreshResponse();
-      }
-    });
+    return alchemyFetch.then(() => this.awaitFallbackIfMissing());
+  }
+
+  // After Alchemy resolves, check Alchemy coverage directly (not via the
+  // observation-driven reaction) so imperative callers also exercise the
+  // batch fallback for tokens missing from Alchemy.
+  protected async awaitFallbackIfMissing(): Promise<void> {
+    const contract = this.denomHelper.contractAddress;
+    const coveredByAlchemy =
+      !!this.parent.response && this.parent.hasAlchemyBalance(contract);
+    if (coveredByAlchemy) return;
+    this.parent.batchParent.addContract(contract);
+    try {
+      await this.parent.batchParent.waitFreshResponse();
+    } finally {
+      this.parent.batchParent.removeContract(contract);
+    }
   }
 
   async waitFreshResponse(): Promise<
     Readonly<QueryResponse<unknown>> | undefined
   > {
     await this.parent.waitFreshResponse();
-    if (this.isInBatch) {
-      await this.parent.batchParent.waitFreshResponse();
-    }
-    return undefined;
+    await this.awaitFallbackIfMissing();
+    return this.response;
   }
 
   async waitResponse(): Promise<Readonly<QueryResponse<unknown>> | undefined> {
     await this.parent.waitResponse();
-    if (this.isInBatch) {
-      await this.parent.batchParent.waitFreshResponse();
-    }
-    return undefined;
+    await this.awaitFallbackIfMissing();
+    return this.response;
   }
 }
 

packages/stores/src/common/query/json-rpc-batch.ts

@@ -96,14 +96,29 @@ export class ObservableJsonRpcBatchQuery<T = unknown> extends ObservableQuery<
 
     const data: Record<string, T> = {};
     const perRequestErrors: Record<string, JsonRpcBatchRequestError> = {};
+    const responded = new Set<string>();
 
     for (const res of response.data) {
+      const id = String(res.id);
+      responded.add(id);
       if (res.error) {
-        perRequestErrors[String(res.id)] = res.error;
+        perRequestErrors[id] = res.error;
         continue;
       }
 
-      data[String(res.id)] = res.result as T;
+      data[id] = res.result as T;
+    }
+
+    // Servers may silently omit IDs on partial failures — synthesize an error
+    // so callers can't sit in permanent loading on a missing response.
+    for (const req of this.requests) {
+      const id = String(req.id);
+      if (!responded.has(id)) {
+        perRequestErrors[id] = {
+          code: -32603,
+          message: `No response for request id ${id}`,
+        };
+      }
     }
 
     runInAction(() => {