@keplr-wallet/stores-eth 0.13.32 → 0.13.34

package/src/queries/erc20-balance.ts

@@ -2,78 +2,159 @@ import {
   BalanceRegistry,
   ChainGetter,
   IObservableQueryBalanceImpl,
+  QueryError,
+  QueryResponse,
   QuerySharedContext,
 } from "@keplr-wallet/stores";
 import { AppCurrency } from "@keplr-wallet/types";
 import { CoinPretty, Int } from "@keplr-wallet/unit";
-import { computed, makeObservable } from "mobx";
+import {
+  computed,
+  makeObservable,
+  observable,
+  onBecomeObserved,
+  onBecomeUnobserved,
+  runInAction,
+} from "mobx";
 import bigInteger from "big-integer";
-import { erc20ContractInterface } from "../constants";
 import { DenomHelper } from "@keplr-wallet/common";
 import { EthereumAccountBase } from "../account";
-import { ObservableEvmChainJsonRpcQuery } from "./evm-chain-json-rpc";
+import { ObservableQueryEthereumERC20BalancesBatchParent } from "./erc20-balance-batch";
+import { ERC20BalanceBatchParentStore } from "./erc20-batch-parent-store";
 
 export class ObservableQueryEthereumERC20BalanceImpl
-  extends ObservableEvmChainJsonRpcQuery<string>
   implements IObservableQueryBalanceImpl
 {
+  @observable
+  protected _observedProps = 0;
+
   constructor(
-    sharedContext: QuerySharedContext,
-    chainId: string,
-    chainGetter: ChainGetter,
+    protected readonly parent: ObservableQueryEthereumERC20BalancesBatchParent,
+    protected readonly chainId: string,
+    protected readonly chainGetter: ChainGetter,
     protected readonly denomHelper: DenomHelper,
-    protected readonly ethereumHexAddress: string,
     protected readonly contractAddress: string
   ) {
-    super(sharedContext, chainId, chainGetter, "eth_call", [
-      {
-        to: contractAddress,
-        data: erc20ContractInterface.encodeFunctionData("balanceOf", [
-          ethereumHexAddress,
-        ]),
-      },
-      "latest",
-    ]);
-
     makeObservable(this);
+
+    // Readiness gates (hooks-evm) can early-return on `response` before
+    // reading `balance`, so either property being observed must register
+    // the contract into the shared batch parent.
+    const attach = (prop: "balance" | "response" | "error") => {
+      onBecomeObserved(this, prop, () => {
+        runInAction(() => {
+          this._observedProps += 1;
+        });
+        if (this._observedProps === 1) {
+          this.parent.addContract(contractAddress);
+        }
+      });
+      onBecomeUnobserved(this, prop, () => {
+        runInAction(() => {
+          this._observedProps -= 1;
+        });
+        if (this._observedProps === 0) {
+          this.parent.removeContract(contractAddress);
+        }
+      });
+    };
+    attach("balance");
+    attach("response");
+    attach("error");
   }
 
   @computed
   get balance(): CoinPretty {
-    const denom = this.denomHelper.denom;
-
-    const currency = this.chainGetter
-      .getModularChain(this.chainId)
-      .findCurrency(denom);
-
-    if (!currency) {
-      throw new Error(`Unknown currency: ${this.contractAddress}`);
-    }
-
-    if (!this.response || !this.response.data) {
+    const currency = this.currency;
+    const raw = this.parent.getBalance(this.contractAddress);
+    if (raw === undefined) {
       return new CoinPretty(currency, new Int(0)).ready(false);
     }
-
     return new CoinPretty(
       currency,
-      new Int(bigInteger(this.response.data.replace("0x", ""), 16).toString())
+      new Int(bigInteger(raw.replace("0x", ""), 16).toString())
     );
   }
 
   @computed
   get currency(): AppCurrency {
-    const denom = this.denomHelper.denom;
+    return this.chainGetter
+      .getModularChain(this.chainId)
+      .forceFindCurrency(this.denomHelper.denom);
+  }
 
+  get isFetching(): boolean {
+    return this.parent.isFetching;
+  }
+  get isObserved(): boolean {
+    return this._observedProps > 0;
+  }
+  get isStarted(): boolean {
+    return this._observedProps > 0;
+  }
+  @computed
+  get error(): QueryError<unknown> | undefined {
+    return this.parent.getError(this.contractAddress);
+  }
+  @computed
+  get response(): Readonly<QueryResponse<unknown>> | undefined {
+    // hooks-evm tx flow gates readiness on truthy `bal.response`. Synthesize
+    // from the shared batch parent so the Child advertises fetch completion.
+    const raw = this.parent.getBalance(this.contractAddress);
+    if (raw === undefined) return undefined;
+    return {
+      data: raw,
+      staled: false,
+      local: false,
+      timestamp: 0,
+    };
+  }
+
+  protected async ensureFetched(): Promise<void> {
+    // balanceImplMap doesn't evict on currency removal.
+    if (!this.isCurrencyRegistered()) return;
+    // 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);
+    }
+  }
+
+  protected isCurrencyRegistered(): boolean {
+    const target = DenomHelper.normalizeDenom(this.denomHelper.denom);
     return this.chainGetter
       .getModularChain(this.chainId)
-      .forceFindCurrency(denom);
+      .currencies.some(
+        (c) => DenomHelper.normalizeDenom(c.coinMinimalDenom) === target
+      );
+  }
+
+  fetch(): Promise<void> {
+    return this.ensureFetched();
+  }
+
+  async waitFreshResponse(): Promise<
+    Readonly<QueryResponse<unknown>> | undefined
+  > {
+    await this.ensureFetched();
+    return this.response;
+  }
+
+  async waitResponse(): Promise<Readonly<QueryResponse<unknown>> | undefined> {
+    return await this.waitFreshResponse();
   }
 }
 
 export class ObservableQueryEthereumERC20BalanceRegistry
   implements BalanceRegistry
 {
-  constructor(protected readonly sharedContext: QuerySharedContext) {}
+  constructor(
+    protected readonly sharedContext: QuerySharedContext,
+    protected readonly batchParentStore: ERC20BalanceBatchParentStore
+  ) {}
 
   getBalanceImpl(
     chainId: string,
@@ -93,12 +174,17 @@ export class ObservableQueryEthereumERC20BalanceRegistry
       return;
     }
 
+    const parent = this.batchParentStore.getOrCreate(
+      chainId,
+      chainGetter,
+      address
+    );
+
     return new ObservableQueryEthereumERC20BalanceImpl(
-      this.sharedContext,
+      parent,
       chainId,
       chainGetter,
       denomHelper,
-      address,
       denomHelper.contractAddress
     );
   }

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

@@ -0,0 +1,194 @@
+import { DenomHelper } from "@keplr-wallet/common";
+import { AppCurrency } from "@keplr-wallet/types";
+import {
+  ObservableQueryThirdpartyERC20BalanceRegistry,
+  ObservableQueryThirdpartyERC20BalancesImpl,
+} from "./erc20-balances";
+
+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 batch = jest.requireActual(
+    "../../../stores/src/common/query/json-rpc-batch"
+  );
+  return {
+    QuerySharedContext: context.QuerySharedContext,
+    ObservableJsonRPCQuery: jsonRpc.ObservableJsonRPCQuery,
+    ObservableJsonRpcBatchQuery: batch.ObservableJsonRpcBatchQuery,
+  };
+});
+
+const CONTRACT = "0x0000000000000000000000000000000000000002";
+const DENOM = `erc20:${CONTRACT}`;
+const CURRENCY: AppCurrency = {
+  coinMinimalDenom: DENOM,
+  coinDenom: "TEST",
+  coinDecimals: 18,
+};
+
+describe("ObservableQueryThirdpartyERC20BalancesImpl", () => {
+  it("falls back to batch eth_call for a missing token when the Alchemy response is complete", async () => {
+    const { parent, batchParent } = mockParent({
+      address: "0x0000000000000000000000000000000000000001",
+      tokenBalances: [],
+    });
+    batchParent.waitFreshResponse.mockImplementation(async () => {
+      batchParent.getBalance.mockReturnValue("0x5");
+    });
+    const balance = createBalance(parent);
+
+    await balance.fetch();
+
+    expect(batchParent.addContract).toHaveBeenCalledWith(CONTRACT);
+    expect(batchParent.waitFreshResponse).toHaveBeenCalledTimes(1);
+    expect(batchParent.removeContract).toHaveBeenCalledWith(CONTRACT);
+    expect(balance.response).not.toBe(parent.response);
+    expect(balance.balance.isReady).toBe(true);
+    expect(balance.balance.toCoin().amount).toBe("5");
+  });
+
+  it("uses the batch parent's cached balance when complete Alchemy response omits the token", async () => {
+    const { parent, batchParent } = mockParent({
+      address: "0x0000000000000000000000000000000000000001",
+      tokenBalances: [],
+    });
+    batchParent.getBalance.mockReturnValue("0x5");
+    const balance = createBalance(parent);
+
+    await balance.fetch();
+
+    expect(batchParent.addContract).toHaveBeenCalledWith(CONTRACT);
+    expect(balance.balance.toCoin().amount).toBe("5");
+  });
+
+  it("falls back to batch eth_call for a missing token when Alchemy has more pages", async () => {
+    const { parent, batchParent } = mockParent({
+      address: "0x0000000000000000000000000000000000000001",
+      tokenBalances: [],
+      pageKey: "next-page",
+    });
+    const balance = createBalance(parent);
+
+    await balance.fetch();
+
+    expect(batchParent.addContract).toHaveBeenCalledWith(CONTRACT);
+    expect(batchParent.waitFreshResponse).toHaveBeenCalledTimes(1);
+    expect(batchParent.removeContract).toHaveBeenCalledWith(CONTRACT);
+  });
+});
+
+describe("ObservableQueryThirdpartyERC20BalanceRegistry", () => {
+  it("does not use the Keplr Alchemy proxy for Optimism", () => {
+    const batchParentStore = {
+      getOrCreate: jest.fn(),
+    };
+    const registry = new ObservableQueryThirdpartyERC20BalanceRegistry(
+      {} as any,
+      batchParentStore as any
+    );
+
+    const impl = registry.getBalanceImpl(
+      "eip155:10",
+      mockChainGetter(),
+      "0x0000000000000000000000000000000000000001",
+      DENOM
+    );
+
+    expect(impl).toBeUndefined();
+    expect(batchParentStore.getOrCreate).not.toHaveBeenCalled();
+  });
+});
+
+function createBalance(
+  parent: ReturnType<typeof mockParent>["parent"]
+): ObservableQueryThirdpartyERC20BalancesImpl {
+  return new ObservableQueryThirdpartyERC20BalancesImpl(
+    parent as any,
+    "eip155:1",
+    mockChainGetter(),
+    new DenomHelper(DENOM)
+  );
+}
+
+function mockParent(data: {
+  address: string;
+  tokenBalances: {
+    contractAddress: string;
+    tokenBalance: string | null;
+    error: { code: number; message: string } | null;
+  }[];
+  pageKey?: string;
+}) {
+  const batchParent = {
+    addContract: jest.fn(),
+    removeContract: jest.fn(),
+    waitFreshResponse: jest.fn().mockResolvedValue(undefined),
+    getBalance: jest.fn(),
+    getLastKnownBalance: jest.fn(),
+    getError: jest.fn(),
+    isFetchingContract: jest.fn(() => false),
+    isFetching: false,
+  };
+  const response = {
+    data,
+    staled: false,
+    local: false,
+    timestamp: 0,
+  };
+  const parent = {
+    response,
+    error: undefined,
+    batchParent,
+    duplicatedFetchResolver: undefined as Promise<void> | undefined,
+    fetch: jest.fn().mockResolvedValue(undefined),
+    hasAlchemyBalance(contract: string) {
+      return data.tokenBalances.some(
+        (bal) =>
+          bal.contractAddress.toLowerCase() === contract.toLowerCase() &&
+          bal.tokenBalance != null
+      );
+    },
+    getAlchemyTokenBalance(contract: string) {
+      return data.tokenBalances.find(
+        (bal) => bal.contractAddress.toLowerCase() === contract.toLowerCase()
+      );
+    },
+    resolvesAlchemyBalance(contract: string) {
+      return this.getAlchemyTokenBalance(contract)?.tokenBalance != null;
+    },
+    isFetching: false,
+    isObserved: false,
+    isStarted: false,
+  };
+
+  return { parent, batchParent };
+}
+
+function mockChainGetter() {
+  return {
+    getModularChain() {
+      return {
+        currencies: [CURRENCY],
+        forceFindCurrency(denom: string) {
+          if (denom === DENOM) {
+            return CURRENCY;
+          }
+          throw new Error(`Unknown currency: ${denom}`);
+        },
+      };
+    },
+    hasModularChain() {
+      return true;
+    },
+  } as any;
+}