@keplr-wallet/stores-eth 0.13.32 → 0.13.34

package/jest.config.js

@@ -1,5 +1,12 @@
 module.exports = {
-  preset: "ts-jest",
   testEnvironment: "node",
+  watchman: false,
+  transform: {
+    "^.+\\.tsx?$": ["ts-jest", { tsconfig: "tsconfig.check.json" }],
+  },
+  moduleNameMapper: {
+    "^@keplr-wallet/(common|crypto|mobx-utils|simple-fetch|stores|types|unit)$":
+      "<rootDir>/../$1/src",
+  },
   testMatch: ["**/src/**/?(*.)+(spec|test).[jt]s?(x)"],
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keplr-wallet/stores-eth",
-  "version": "0.13.32",
+  "version": "0.13.34",
   "main": "build/index.js",
   "author": "chainapsis",
   "license": "Apache-2.0",
@@ -27,12 +27,12 @@
     "@ethersproject/strings": "^5.7.0",
     "@ethersproject/transactions": "^5.7.0",
     "@ethersproject/units": "^5.7.0",
-    "@keplr-wallet/common": "0.13.32",
-    "@keplr-wallet/simple-fetch": "0.13.32",
-    "@keplr-wallet/stores": "0.13.32",
-    "@keplr-wallet/stores-etc": "0.13.32",
-    "@keplr-wallet/types": "0.13.32",
-    "@keplr-wallet/unit": "0.13.32",
+    "@keplr-wallet/common": "0.13.34",
+    "@keplr-wallet/simple-fetch": "0.13.34",
+    "@keplr-wallet/stores": "0.13.34",
+    "@keplr-wallet/stores-etc": "0.13.34",
+    "@keplr-wallet/types": "0.13.34",
+    "@keplr-wallet/unit": "0.13.34",
     "big-integer": "^1.6.48",
     "lodash.debounce": "^4.0.8",
     "utility-types": "^3.10.0"
@@ -44,5 +44,5 @@
   "devDependencies": {
     "@types/lodash.debounce": "^4"
   },
-  "gitHead": "afca64992d57ad196660a44822328bc8f09dbfc8"
+  "gitHead": "261583540739c6e916c78905e587a2d82575bdc0"
 }

package/src/queries/erc20-balance-batch.spec.ts

@@ -0,0 +1,192 @@
+import { MemoryKVStore } from "@keplr-wallet/common";
+import { simpleFetch } from "@keplr-wallet/simple-fetch";
+import { ChainGetter, QuerySharedContext } from "@keplr-wallet/stores";
+import { autorun } from "mobx";
+import { ObservableQueryEthereumERC20BalancesBatchParent } from "./erc20-balance-batch";
+
+jest.mock("@keplr-wallet/stores", () => {
+  const context = jest.requireActual(
+    "../../../stores/src/common/query/context"
+  );
+  const batch = jest.requireActual(
+    "../../../stores/src/common/query/json-rpc-batch"
+  );
+  return {
+    QuerySharedContext: context.QuerySharedContext,
+    ObservableJsonRpcBatchQuery: batch.ObservableJsonRpcBatchQuery,
+  };
+});
+
+jest.mock("@keplr-wallet/simple-fetch", () => {
+  const actual = jest.requireActual("@keplr-wallet/simple-fetch");
+  return {
+    ...actual,
+    simpleFetch: jest.fn(),
+  };
+});
+
+const ADDRESS = "0x0000000000000000000000000000000000000001";
+const CONTRACT_A = "0x0000000000000000000000000000000000000002";
+const CONTRACT_B = "0x0000000000000000000000000000000000000003";
+
+type PendingFetch = {
+  body: { id: string }[];
+  resolve: (value: { headers: Record<string, unknown>; data: unknown }) => void;
+};
+
+describe("ObservableQueryEthereumERC20BalancesBatchParent", () => {
+  let pendingFetches: PendingFetch[];
+
+  beforeEach(() => {
+    pendingFetches = [];
+    (simpleFetch as jest.Mock).mockImplementation(
+      (_baseURL: string, _url: string, options: { body: string }) => {
+        return new Promise((resolve) => {
+          pendingFetches.push({
+            body: JSON.parse(options.body),
+            resolve: resolve as PendingFetch["resolve"],
+          });
+        });
+      }
+    );
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("keeps the last known contract balance while the batch layout is rebuilt", async () => {
+    const parent = new ObservableQueryEthereumERC20BalancesBatchParent(
+      new QuerySharedContext(new MemoryKVStore("erc20-balance-batch-test"), {
+        responseDebounceMs: 0,
+      }),
+      "eip155:1",
+      mockChainGetter(),
+      ADDRESS
+    );
+
+    parent.addContract(CONTRACT_A);
+    const firstWait = parent.waitFreshResponse();
+    await waitForPendingFetches(pendingFetches, 1);
+    resolveFetch(pendingFetches[0], {
+      [CONTRACT_A]: "0x1",
+    });
+    await firstWait;
+
+    expect(parent.getBalance(CONTRACT_A)).toBe("0x1");
+
+    parent.addContract(CONTRACT_B);
+    const secondWait = parent.waitFreshResponse();
+    await waitForPendingFetches(pendingFetches, 2);
+
+    expect(parent.getBalance(CONTRACT_A)).toBe("0x1");
+
+    resolveFetch(pendingFetches[1], {
+      [CONTRACT_A]: "0x2",
+      [CONTRACT_B]: "0x3",
+    });
+    await secondWait;
+
+    expect(parent.getBalance(CONTRACT_A)).toBe("0x2");
+    expect(parent.getBalance(CONTRACT_B)).toBe("0x3");
+  });
+
+  it("starts a rebuilt query while serving a last known balance", async () => {
+    const parent = new ObservableQueryEthereumERC20BalancesBatchParent(
+      new QuerySharedContext(new MemoryKVStore("erc20-balance-batch-test"), {
+        responseDebounceMs: 0,
+      }),
+      "eip155:1",
+      mockChainGetter(),
+      ADDRESS
+    );
+
+    parent.addContract(CONTRACT_A);
+    const firstWait = parent.waitFreshResponse();
+    await waitForPendingFetches(pendingFetches, 1);
+    resolveFetch(pendingFetches[0], {
+      [CONTRACT_A]: "0x1",
+    });
+    await firstWait;
+
+    parent.removeContract(CONTRACT_A);
+    await wait(250);
+    parent.addContract(CONTRACT_A);
+    await wait(250);
+
+    const disposers = [
+      autorun(() => parent.getBalance(CONTRACT_A)),
+      autorun(() => parent.getError(CONTRACT_A)),
+      autorun(() => parent.isFetchingContract(CONTRACT_A)),
+    ];
+
+    await waitForPendingFetches(pendingFetches, 2);
+
+    expect(parent.getBalance(CONTRACT_A)).toBe("0x1");
+
+    resolveFetch(pendingFetches[1], {
+      [CONTRACT_A]: "0x2",
+    });
+    await waitForCondition(() => parent.getBalance(CONTRACT_A) === "0x2");
+
+    expect(parent.getBalance(CONTRACT_A)).toBe("0x2");
+
+    disposers.forEach((dispose) => dispose());
+  });
+});
+
+function mockChainGetter(): ChainGetter {
+  return {
+    getModularChain() {
+      return {
+        unwrapped: {
+          type: "evm",
+          evm: {
+            rpc: "https://rpc.example",
+          },
+        },
+      } as ReturnType<ChainGetter["getModularChain"]>;
+    },
+    hasModularChain() {
+      return true;
+    },
+  };
+}
+
+function resolveFetch(fetch: PendingFetch, results: Record<string, string>) {
+  fetch.resolve({
+    headers: {},
+    data: fetch.body.map((req) => ({
+      jsonrpc: "2.0",
+      id: req.id,
+      result: results[req.id] ?? "0x0",
+    })),
+  });
+}
+
+async function waitForPendingFetches(
+  pendingFetches: PendingFetch[],
+  count: number
+) {
+  const startedAt = Date.now();
+  while (pendingFetches.length < count) {
+    if (Date.now() - startedAt > 2000) {
+      throw new Error(`Timed out waiting for ${count} fetches`);
+    }
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+}
+
+function wait(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function waitForCondition(fn: () => boolean) {
+  const startedAt = Date.now();
+  while (!fn()) {
+    if (Date.now() - startedAt > 2000) {
+      throw new Error("Timed out waiting for condition");
+    }
+    await wait(10);
+  }
+}

package/src/queries/erc20-balance-batch.ts

@@ -0,0 +1,273 @@
+import {
+  ChainGetter,
+  JsonRpcBatchRequest,
+  ObservableJsonRpcBatchQuery,
+  QueryError,
+  QuerySharedContext,
+} from "@keplr-wallet/stores";
+import { makeObservable, observable, reaction, runInAction, when } from "mobx";
+import { erc20ContractInterface } from "../constants";
+
+const BATCH_CHUNK_SIZE = 10;
+const REBUILD_DEBOUNCE_MS = 200;
+
+export class ObservableQueryEthereumERC20BalancesBatchParent {
+  @observable.shallow
+  protected refcount: Map<string, number> = new Map();
+
+  @observable.ref
+  protected batchQueries: ObservableJsonRpcBatchQuery<string>[] = [];
+
+  @observable.ref
+  protected batchQueryKeys: string[] = [];
+
+  @observable.shallow
+  protected lastKnownBalances: Map<string, string> = new Map();
+
+  @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,
+    protected readonly chainGetter: ChainGetter,
+    protected readonly ethereumHexAddress: string
+  ) {
+    makeObservable(this);
+
+    reaction(
+      () => {
+        const keys = Array.from(this.refcount.keys()).sort().join(",");
+        // Include the RPC URL so a runtime endpoint change (user-configured
+        // custom RPC) triggers a rebuild against the new endpoint.
+        return `${this.getRpcUrl()}::${keys}`;
+      },
+      (key) => this.rebuildBatchQueries(key),
+      { fireImmediately: true, delay: REBUILD_DEBOUNCE_MS }
+    );
+  }
+
+  addContract(contract: string): void {
+    const key = contract.toLowerCase();
+    runInAction(() => {
+      this.refcount.set(key, (this.refcount.get(key) ?? 0) + 1);
+    });
+  }
+
+  removeContract(contract: string): void {
+    const key = contract.toLowerCase();
+    const n = this.refcount.get(key);
+    if (n === undefined) return;
+    runInAction(() => {
+      if (n <= 1) {
+        this.refcount.delete(key);
+      } else {
+        this.refcount.set(key, n - 1);
+      }
+    });
+  }
+
+  getBalance(contract: string): string | undefined {
+    const key = contract.toLowerCase();
+    const lastKnown = this.lastKnownBalances.get(key);
+    for (const q of this.batchQueries) {
+      trackQueryFetching(q);
+      if (!q.isStarted && lastKnown !== undefined) {
+        continue;
+      }
+
+      const data = q.response?.data?.[key];
+      if (data !== undefined) return data;
+    }
+    return lastKnown;
+  }
+
+  getLastKnownBalance(contract: string): string | undefined {
+    return this.lastKnownBalances.get(contract.toLowerCase());
+  }
+
+  get isFetching(): boolean {
+    return this.batchQueries.some((q) => q.isFetching);
+  }
+
+  isFetchingContract(contract: string): boolean {
+    const key = contract.toLowerCase();
+    const chunkIdx = this.chunkIndex.get(key);
+    if (chunkIdx === undefined) return false;
+    const q = this.batchQueries[chunkIdx];
+    if (!q) return false;
+    const isFetching = trackQueryFetching(q);
+    if (!q.isStarted && this.lastKnownBalances.has(key)) return false;
+    return isFetching;
+  }
+
+  // Per-contract error: surface only the error of the chunk that owns this
+  // 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 chunkIdx = this.chunkIndex.get(key);
+    if (chunkIdx === undefined) return undefined;
+    const q = this.batchQueries[chunkIdx];
+    if (!q) return undefined;
+    trackQueryFetching(q);
+    if (!q.isStarted && this.lastKnownBalances.has(key)) 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;
+  }
+
+  protected currentKey(): string {
+    const keys = Array.from(this.refcount.keys()).sort().join(",");
+    return `${this.getRpcUrl()}::${keys}`;
+  }
+
+  async waitFreshResponse(): Promise<void> {
+    // The reaction that rebuilds batchQueries is debounced, so refcount can
+    // change without batchQueries catching up. Wait until the built key
+    // matches the current (refcount + rpc) snapshot.
+    await when(() => this.currentKey() === this.lastBuiltKey);
+    await Promise.all(this.batchQueries.map((q) => q.waitFreshResponse()));
+    this.rememberCurrentBatchBalances();
+  }
+
+  protected rebuildBatchQueries(key: string): void {
+    this.rememberCurrentBatchBalances();
+
+    if (this.refcount.size === 0) {
+      runInAction(() => {
+        this.batchQueries = [];
+        this.batchQueryKeys = [];
+        this.lastBuiltKey = key;
+        this.chunkIndex = new Map();
+      });
+      return;
+    }
+
+    const rpcUrl = this.getRpcUrl();
+    if (!rpcUrl) {
+      runInAction(() => {
+        this.batchQueries = [];
+        this.batchQueryKeys = [];
+        this.lastBuiltKey = key;
+        this.chunkIndex = new Map();
+      });
+      return;
+    }
+
+    const contracts = Array.from(this.refcount.keys()).sort();
+    const chunks = chunkArray(contracts, BATCH_CHUNK_SIZE);
+
+    const calldata = (to: string) => ({
+      to,
+      data: erc20ContractInterface.encodeFunctionData("balanceOf", [
+        this.ethereumHexAddress,
+      ]),
+    });
+
+    const nextChunkIndex = new Map<string, number>();
+    chunks.forEach((chunk, idx) => {
+      for (const c of chunk) nextChunkIndex.set(c, idx);
+    });
+
+    const previousQueries = new Map<
+      string,
+      ObservableJsonRpcBatchQuery<string>
+    >();
+    this.batchQueries.forEach((q, idx) => {
+      const queryKey = this.batchQueryKeys[idx];
+      if (queryKey) {
+        previousQueries.set(queryKey, q);
+      }
+    });
+
+    const nextBatchQueryKeys = chunks.map(
+      (chunk) => `${rpcUrl}::${chunk.join(",")}`
+    );
+
+    runInAction(() => {
+      this.batchQueries = chunks.map((chunk, idx) => {
+        const queryKey = nextBatchQueryKeys[idx];
+        const previous = previousQueries.get(queryKey);
+        if (previous) {
+          return previous;
+        }
+
+        const requests: JsonRpcBatchRequest[] = chunk.map((c) => ({
+          method: "eth_call",
+          params: [calldata(c), "latest"],
+          id: c,
+        }));
+        return new ObservableJsonRpcBatchQuery<string>(
+          this.sharedContext,
+          rpcUrl,
+          "",
+          requests
+        );
+      });
+      this.batchQueryKeys = nextBatchQueryKeys;
+      this.lastBuiltKey = key;
+      this.chunkIndex = nextChunkIndex;
+    });
+  }
+
+  protected rememberCurrentBatchBalances(): void {
+    const entries: [string, string][] = [];
+    for (const q of this.batchQueries) {
+      const data = q.response?.data;
+      if (!data) {
+        continue;
+      }
+
+      for (const [contract, balance] of Object.entries(data)) {
+        entries.push([contract.toLowerCase(), balance]);
+      }
+    }
+
+    if (entries.length === 0) {
+      return;
+    }
+
+    runInAction(() => {
+      for (const [contract, balance] of entries) {
+        this.lastKnownBalances.set(contract, balance);
+      }
+    });
+  }
+
+  protected getRpcUrl(): string {
+    const u = this.chainGetter.getModularChain(this.chainId).unwrapped;
+    return u.type === "evm" || u.type === "ethermint" ? u.evm.rpc : "";
+  }
+}
+
+function chunkArray<T>(array: T[], size: number): T[][] {
+  const chunks: T[][] = [];
+  for (let i = 0; i < array.length; i += size) {
+    chunks.push(array.slice(i, i + size));
+  }
+  return chunks;
+}
+
+function trackQueryFetching(
+  query: ObservableJsonRpcBatchQuery<string>
+): boolean {
+  // Reading `isFetching` starts ObservableQuery when a caller observes the
+  // parent state, while still letting getters return cached last-known data.
+  return query.isFetching;
+}

package/src/queries/erc20-balance.spec.ts

@@ -0,0 +1,129 @@
+import { MemoryKVStore } from "@keplr-wallet/common";
+import { ChainGetter, QuerySharedContext } from "@keplr-wallet/stores";
+import {
+  ObservableQueryEthereumERC20BalanceImpl,
+  ObservableQueryEthereumERC20BalanceRegistry,
+} from "./erc20-balance";
+
+jest.mock("../account", () => ({
+  EthereumAccountBase: {
+    isEthereumHexAddressWithChecksum: jest.fn(() => true),
+  },
+}));
+
+jest.mock("@keplr-wallet/stores", () => {
+  const context = jest.requireActual(
+    "../../../stores/src/common/query/context"
+  );
+  const jsonRpc = jest.requireActual(
+    "../../../stores/src/common/query/json-rpc"
+  );
+  const map = jest.requireActual("../../../stores/src/common/map");
+  return {
+    QuerySharedContext: context.QuerySharedContext,
+    ObservableJsonRPCQuery: jsonRpc.ObservableJsonRPCQuery,
+    HasMapStore: map.HasMapStore,
+    getKeplrFromWindow: jest.fn(),
+  };
+});
+
+const ADDRESS = "0x0000000000000000000000000000000000000001";
+const CONTRACT = "0x0000000000000000000000000000000000000002";
+const DENOM = `erc20:${CONTRACT}`;
+const CURRENCY = {
+  coinMinimalDenom: DENOM,
+  coinDenom: "TEST",
+  coinDecimals: 18,
+};
+
+describe("ObservableQueryEthereumERC20BalanceRegistry", () => {
+  it("keeps ethermint ERC20 balances on the shared batch query for hex senders", () => {
+    const batchParentStore = mockBatchParentStore();
+    const chainGetter = mockChainGetter("ethermint");
+    const registry = createRegistry(batchParentStore);
+
+    const impl = registry.getBalanceImpl(
+      "injective-1",
+      chainGetter,
+      ADDRESS,
+      DENOM
+    );
+
+    expect(impl).toBeInstanceOf(ObservableQueryEthereumERC20BalanceImpl);
+    expect(batchParentStore.getOrCreate).toHaveBeenCalledWith(
+      "injective-1",
+      chainGetter,
+      ADDRESS
+    );
+  });
+
+  it("keeps pure EVM ERC20 balances on the shared batch query", () => {
+    const batchParentStore = mockBatchParentStore();
+    const chainGetter = mockChainGetter("evm");
+    const registry = createRegistry(batchParentStore);
+
+    const impl = registry.getBalanceImpl(
+      "eip155:1",
+      chainGetter,
+      ADDRESS,
+      DENOM
+    );
+
+    expect(impl).toBeInstanceOf(ObservableQueryEthereumERC20BalanceImpl);
+    expect(batchParentStore.getOrCreate).toHaveBeenCalledWith(
+      "eip155:1",
+      chainGetter,
+      ADDRESS
+    );
+  });
+});
+
+function createRegistry(
+  batchParentStore: ReturnType<typeof mockBatchParentStore>
+) {
+  return new ObservableQueryEthereumERC20BalanceRegistry(
+    new QuerySharedContext(new MemoryKVStore("erc20-balance-registry-test"), {
+      responseDebounceMs: 0,
+    }),
+    batchParentStore as any
+  );
+}
+
+function mockBatchParentStore() {
+  return {
+    getOrCreate: jest.fn(() => ({
+      addContract: jest.fn(),
+      removeContract: jest.fn(),
+      waitFreshResponse: jest.fn(),
+      getBalance: jest.fn(),
+      getError: jest.fn(),
+      isFetching: false,
+    })),
+  };
+}
+
+function mockChainGetter(type: "evm" | "ethermint"): ChainGetter {
+  return {
+    getModularChain() {
+      return {
+        type,
+        unwrapped: {
+          type,
+          evm: {
+            rpc: "https://rpc.example",
+          },
+        },
+        currencies: [CURRENCY],
+        forceFindCurrency(denom: string) {
+          if (denom === DENOM) {
+            return CURRENCY;
+          }
+          throw new Error(`Unknown currency: ${denom}`);
+        },
+      } as ReturnType<ChainGetter["getModularChain"]>;
+    },
+    hasModularChain() {
+      return true;
+    },
+  };
+}