fix(stores,stores-eth): force-register on imperative fetch + surface per-request batch errors

- Imperative ERC20 fetch() outside a reactive observer no longer falls
  through: the Child now force-adds/removes the contract around
  waitFreshResponse so post-send refresh paths actually issue an
  eth_call even when nothing is observing balance/response yet.
- ObservableJsonRpcBatchQuery exposes per-request errors via a new
  perRequestErrors map. Individual failures inside a batch response
  were previously dropped silently, leaving bad contract addresses
  stuck at ready(false) with no error signal. BatchParent.getError
  checks this map so per-contract error propagation works for both
  HTTP-level and per-request failures.

Author: piatoss3612

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

@@ -70,14 +70,27 @@ export class ObservableQueryEthereumERC20BalancesBatchParent {
   }
 
   // Per-contract error: surface only the error of the chunk that owns this
-  // contract, so a failing chunk doesn't contaminate siblings in other chunks.
+  // contract, plus any per-request error the batch returned for it. A failing
+  // chunk no longer contaminates siblings in other chunks.
   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);
-    return this.batchQueries[chunkIdx]?.error;
+    const q = this.batchQueries[chunkIdx];
+    if (!q) return undefined;
+    if (q.error) return q.error;
+    const perReq = q.perRequestErrors[key];
+    if (perReq) {
+      return {
+        status: 0,
+        statusText: "batch-request-error",
+        message: perReq.message,
+        data: perReq as unknown,
+      };
+    }
+    return undefined;
   }
 
   async waitFreshResponse(): Promise<void> {

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

@@ -108,14 +108,25 @@ export class ObservableQueryEthereumERC20BalanceImpl
     };
   }
 
+  protected async ensureFetched(): Promise<void> {
+    // Force temporary registration so imperative callers (outside a reactive
+    // observer) still trigger an actual eth_call.
+    this.parent.addContract(this.contractAddress);
+    try {
+      await this.parent.waitFreshResponse();
+    } finally {
+      this.parent.removeContract(this.contractAddress);
+    }
+  }
+
   fetch(): Promise<void> {
-    return this.parent.waitFreshResponse();
+    return this.ensureFetched();
   }
 
   async waitFreshResponse(): Promise<
     Readonly<QueryResponse<unknown>> | undefined
   > {
-    await this.parent.waitFreshResponse();
+    await this.ensureFetched();
     return undefined;
   }
 

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

@@ -4,20 +4,32 @@ import { simpleFetch } from "@keplr-wallet/simple-fetch";
 import { JsonRpcResponse } from "@keplr-wallet/types";
 import { Hash } from "@keplr-wallet/crypto";
 import { Buffer } from "buffer/";
+import { makeObservable, observable, runInAction } from "mobx";
 
 export interface JsonRpcBatchRequest {
   method: string;
   params: unknown;
   id: string;
 }
 
+export interface JsonRpcBatchRequestError {
+  code: number;
+  message: string;
+  data?: unknown;
+}
+
 /**
  * Observable query for batched JSON-RPC requests.
  * Manages an array of `JsonRpcBatchRequest` and returns a map of results keyed by request ID.
+ * Per-request errors (when the batch HTTP call succeeds but individual calls fail)
+ * are surfaced via `perRequestErrors`.
  */
 export class ObservableJsonRpcBatchQuery<T = unknown> extends ObservableQuery<
   Record<string, T>
 > {
+  @observable.ref
+  protected _perRequestErrors: Record<string, JsonRpcBatchRequestError> = {};
+
   constructor(
     sharedContext: QuerySharedContext,
     baseURL: string,
@@ -26,6 +38,11 @@ export class ObservableJsonRpcBatchQuery<T = unknown> extends ObservableQuery<
     options: Partial<QueryOptions> = {}
   ) {
     super(sharedContext, baseURL, url, options);
+    makeObservable(this);
+  }
+
+  get perRequestErrors(): Readonly<Record<string, JsonRpcBatchRequestError>> {
+    return this._perRequestErrors;
   }
 
   protected override getCacheKey(): string {
@@ -78,15 +95,21 @@ export class ObservableJsonRpcBatchQuery<T = unknown> extends ObservableQuery<
     }
 
     const data: Record<string, T> = {};
+    const perRequestErrors: Record<string, JsonRpcBatchRequestError> = {};
 
     for (const res of response.data) {
       if (res.error) {
+        perRequestErrors[String(res.id)] = res.error;
         continue;
       }
 
       data[String(res.id)] = res.result as T;
     }
 
+    runInAction(() => {
+      this._perRequestErrors = perRequestErrors;
+    });
+
     return {
       headers: response.headers,
       data,