@b3dotfun/sdk 0.1.70-alpha.17 → 0.1.70-alpha.19

package/src/global-account/react/hooks/usePortfolioBalance.ts

@@ -0,0 +1,89 @@
+import { useQuery } from "@tanstack/react-query";
+import {
+  adaptZerionPositions,
+  balanceMatchesToken,
+  type B3TokenBalance,
+  type ZerionPositionLike,
+} from "@b3dotfun/sdk/shared/utils/zerionPositions";
+
+/**
+ * Wallet holdings, read through the b3 portfolio proxy.
+ *
+ * The proxy holds the upstream API key server-side and authorizes browsers by Origin allowlist, so
+ * nothing secret ships to the client and no key is accepted from it. A consumer served from an
+ * origin the proxy does not know will be refused — adding an origin is a proxy config change, not
+ * an SDK change.
+ */
+const PORTFOLIO_API_BASE_URL = "https://portfolio-api.b3.fun";
+
+interface ZerionPositionsResponse {
+  data?: ZerionPositionLike[];
+}
+
+/**
+ * Fetch every spendable holding for a wallet in one request.
+ *
+ * Deliberately unpaginated and unfiltered by chain. The positions endpoint returns a wallet's full
+ * simple-position list in a single response, and passing a chain filter is actively harmful: the
+ * upstream rejects a handful of otherwise-valid chain slugs and fails the WHOLE request when one
+ * appears, so a caller asking for five chains can lose all five. Callers narrow the result instead.
+ */
+async function fetchWalletPositions(address: string): Promise<B3TokenBalance[]> {
+  const url = `${PORTFOLIO_API_BASE_URL}/v1/wallets/${encodeURIComponent(address)}/positions/?filter[positions]=only_simple`;
+  const response = await fetch(url, { headers: { Accept: "application/json" } });
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch wallet balances: ${response.status} ${response.statusText}`);
+  }
+
+  const body = (await response.json()) as ZerionPositionsResponse;
+  return adaptZerionPositions(body.data ?? []);
+}
+
+/**
+ * Keyed by wallet alone so every consumer of the same wallet shares one fetch and one cache entry.
+ * Keying by the requested chain subset instead would refetch per caller and share nothing.
+ */
+function walletPositionsQueryKey(address?: string) {
+  return ["walletPositions", address] as const;
+}
+
+/**
+ * Holdings for a wallet, optionally narrowed to specific chains.
+ *
+ * Read `isError` before reading `data`: a failed read and an empty wallet are different facts, and
+ * rendering the first as the second tells the user they hold nothing when nobody knows.
+ */
+export function usePortfolioBalance(address?: string, chainIds?: number[]) {
+  const wantedChainIds = chainIds && chainIds.length > 0 ? chainIds : undefined;
+
+  return useQuery({
+    queryKey: walletPositionsQueryKey(address),
+    queryFn: () => {
+      if (!address) throw new Error("Address is required");
+      return fetchWalletPositions(address);
+    },
+    enabled: Boolean(address),
+    select: (balances: B3TokenBalance[]) =>
+      wantedChainIds ? balances.filter(balance => wantedChainIds.includes(balance.chain_id)) : balances,
+  });
+}
+
+/**
+ * One token's balance for a wallet, served from the same per-wallet fetch as {@link usePortfolioBalance}.
+ *
+ * `tokenAddress` may be a contract address or the chain's native sentinel; matching is
+ * case-insensitive because callers pass addresses in whatever casing their source used.
+ */
+export function usePortfolioTokenBalance(walletAddress?: string, tokenAddress?: string, chainId?: number) {
+  return useQuery({
+    queryKey: walletPositionsQueryKey(walletAddress),
+    queryFn: () => {
+      if (!walletAddress) throw new Error("Address is required");
+      return fetchWalletPositions(walletAddress);
+    },
+    enabled: Boolean(walletAddress) && Boolean(tokenAddress) && Boolean(chainId),
+    select: (balances: B3TokenBalance[]) =>
+      balances.find(balance => balance.chain_id === chainId && balanceMatchesToken(balance, tokenAddress ?? "")),
+  });
+}

package/src/global-account/react/hooks/usePortfolioCollectibles.ts

@@ -0,0 +1,212 @@
+import type { NFT, SimpleHashNFTResponse } from "@b3dotfun/sdk/global-account/types/simplehash.types";
+import { zerionSlugToChainId } from "@b3dotfun/sdk/shared/utils/zerionPositions";
+import { useQuery } from "@tanstack/react-query";
+
+const PORTFOLIO_API_BASE_URL = "https://portfolio-api.b3.fun";
+
+interface ZerionNftPosition {
+  id?: string;
+  attributes?: {
+    amount?: string;
+    changed_at?: string;
+    nft_info?: {
+      contract_address?: string;
+      token_id?: string;
+      name?: string;
+      interface?: string;
+      content?: { preview?: { url?: string }; detail?: { url?: string } };
+      flags?: { is_spam?: boolean };
+    };
+    collection_info?: {
+      name?: string;
+      description?: string;
+      content?: { icon?: { url?: string } };
+    };
+  };
+  relationships?: { chain?: { data?: { id?: string } } };
+}
+
+interface ZerionNftPositionsResponse {
+  data?: ZerionNftPosition[];
+}
+
+/** Caps an ERC-1155 balance string at MAX_SAFE_INTEGER so a huge supply cannot overflow. */
+function safeParseBalance(balance: string | undefined): number {
+  if (!balance) return 1;
+  const parsed = parseInt(balance, 10);
+  if (Number.isNaN(parsed)) return 1;
+  return Math.min(parsed, Number.MAX_SAFE_INTEGER);
+}
+
+/**
+ * Reshape one Zerion NFT position into the SimpleHash record `AccountAssets` renders.
+ *
+ * Fields Zerion does not carry — traits, rarity, royalties, sale history — stay empty rather than
+ * being synthesised from something adjacent. In particular the position's `price` is a current
+ * estimate, not a sale, so it must not be written into `last_sale`.
+ */
+function toSimpleHashNft(position: ZerionNftPosition, ownerAddress: string): NFT | null {
+  const attributes = position.attributes ?? {};
+  const nftInfo = attributes.nft_info;
+  const slug = position.relationships?.chain?.data?.id;
+  if (!nftInfo?.contract_address || !nftInfo.token_id || !slug) return null;
+
+  const imageUrl = nftInfo.content?.detail?.url ?? nftInfo.content?.preview?.url ?? "";
+  const collectionInfo = attributes.collection_info ?? {};
+  const acquiredAt = attributes.changed_at ?? "";
+
+  return {
+    nft_id: `${slug}.${nftInfo.contract_address}.${nftInfo.token_id}`,
+    chain: slug,
+    contract_address: nftInfo.contract_address,
+    token_id: nftInfo.token_id,
+    name: nftInfo.name || "",
+    description: collectionInfo.description || "",
+    previews: {
+      image_small_url: nftInfo.content?.preview?.url ?? imageUrl,
+      image_medium_url: imageUrl,
+      image_large_url: imageUrl,
+      image_opengraph_url: imageUrl,
+      blurhash: "",
+      predominant_color: "",
+    },
+    image_url: imageUrl,
+    image_properties: { width: 0, height: 0, size: 0, mime_type: "", exif_orientation: null },
+    video_url: null,
+    video_properties: null,
+    audio_url: null,
+    audio_properties: null,
+    model_url: null,
+    model_properties: null,
+    other_url: null,
+    other_properties: null,
+    background_color: null,
+    external_url: null,
+    created_date: "",
+    status: "minted",
+    token_count: 1,
+    owner_count: 1,
+    owners: [
+      {
+        owner_address: ownerAddress,
+        quantity: safeParseBalance(attributes.amount),
+        quantity_string: attributes.amount || "1",
+        first_acquired_date: acquiredAt,
+        last_acquired_date: acquiredAt,
+      },
+    ],
+    contract: {
+      type: nftInfo.interface === "ERC1155" ? "ERC1155" : "ERC721",
+      name: collectionInfo.name || "",
+      symbol: null,
+      deployed_by: "",
+      deployed_via_contract: "",
+      owned_by: "",
+      has_multiple_collections: false,
+    },
+    collection: {
+      collection_id: nftInfo.contract_address,
+      name: collectionInfo.name || "Unknown Collection",
+      description: collectionInfo.description ?? null,
+      image_url: collectionInfo.content?.icon?.url ?? "",
+      image_properties: { width: 0, height: 0, mime_type: "" },
+      banner_image_url: null,
+      category: null,
+      is_nsfw: null,
+      external_url: null,
+      twitter_username: null,
+      discord_url: null,
+      instagram_username: null,
+      medium_username: null,
+      telegram_url: null,
+      marketplace_pages: [],
+      metaplex_mint: null,
+      metaplex_candy_machine: null,
+      metaplex_first_verified_creator: null,
+      floor_prices: [],
+      top_bids: [],
+      distinct_owner_count: 0,
+      distinct_nft_count: 0,
+      total_quantity: 0,
+      chains: [slug],
+      top_contracts: [nftInfo.contract_address],
+      collection_royalties: [],
+    },
+    last_sale: null,
+    primary_sale: null,
+    first_created: {
+      minted_to: ownerAddress,
+      quantity: 1,
+      quantity_string: "1",
+      timestamp: "",
+      block_number: 0,
+      transaction: "",
+      transaction_initiator: "",
+    },
+    rarity: { rank: null, score: null, unique_attributes: null },
+    royalty: [],
+    extra_metadata: {
+      attributes: [],
+      image_original_url: imageUrl,
+      animation_original_url: null,
+      metadata_original_url: "",
+    },
+  };
+}
+
+/**
+ * NFTs held by a wallet, in the SimpleHash shape `AccountAssets` already renders.
+ *
+ * Chain narrowing happens here rather than in the request: the upstream rejects some valid chain
+ * slugs outright and fails the whole request when one is present, so asking for a subset can cost
+ * you the whole answer.
+ */
+export function usePortfolioCollectibles(
+  address?: string,
+  chainIds?: number[],
+  options?: { limit?: number; filterSpam?: boolean },
+) {
+  const limit = options?.limit;
+  const filterSpam = options?.filterSpam;
+  const wantedChainIds = chainIds && chainIds.length > 0 ? chainIds : undefined;
+
+  return useQuery({
+    queryKey: ["walletCollectibles", address, limit, filterSpam],
+    queryFn: async (): Promise<SimpleHashNFTResponse> => {
+      if (!address) throw new Error("Address is required");
+
+      const params = new URLSearchParams();
+      if (limit) params.set("page[size]", String(limit));
+      const query = params.toString();
+      const url = `${PORTFOLIO_API_BASE_URL}/v1/wallets/${encodeURIComponent(address)}/nft-positions/${query ? `?${query}` : ""}`;
+
+      const response = await fetch(url, { headers: { Accept: "application/json" } });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch collectibles: ${response.status} ${response.statusText}`);
+      }
+
+      const body = (await response.json()) as ZerionNftPositionsResponse;
+      // Spam is dropped here, not in `select`: the flag lives on the raw position and the
+      // SimpleHash shape has nowhere to carry it downstream.
+      const nfts = (body.data ?? [])
+        .filter(position => !(filterSpam && position.attributes?.nft_info?.flags?.is_spam === true))
+        .map(position => toSimpleHashNft(position, address))
+        .filter((nft): nft is NFT => nft !== null);
+
+      return { next_cursor: null, next: null, previous: null, nfts };
+    },
+    enabled: Boolean(address),
+    staleTime: 30 * 1000,
+    gcTime: 5 * 60 * 1000,
+    select: (data: SimpleHashNFTResponse) => {
+      if (!wantedChainIds) return data;
+
+      const all = data.nfts ?? [];
+      const nfts = all.filter(nft => {
+        const chainId = zerionSlugToChainId(nft.chain);
+        return chainId !== undefined && wantedChainIds.includes(chainId);
+      });
+      return nfts.length === all.length ? data : { ...data, nfts };
+    },
+  });
+}

package/src/global-account/react/hooks/useUnifiedChainSwitchAndExecute.ts

@@ -10,7 +10,6 @@ import { prepareTransaction, sendTransaction as twSendTransaction } from "thirdw
 import { isAddress } from "viem";
 import { useSwitchChain } from "wagmi";
 import { useB3Config } from "../components/B3Provider/B3ConfigProvider";
-import { useB3Account } from "../components/B3Provider/useB3Account";
 import { useAccountWallet } from "./useAccountWallet";
 
 export interface UnifiedTransactionParams {
@@ -23,8 +22,7 @@ export function useUnifiedChainSwitchAndExecute() {
   const { switchChainAsync } = useSwitchChain();
   const [isSwitchingOrExecuting, setIsSwitchingOrExecuting] = useState(false);
 
-  const { isActiveSmartWallet, isActiveEOAWallet, connectedEOAWallet } = useAccountWallet();
-  const aaAccount = useB3Account();
+  const { isActiveSmartWallet, isActiveEOAWallet, connectedSmartWallet, connectedEOAWallet } = useAccountWallet();
 
   // From context, not process.env: partnerId is hashed into the server intent key and must match the ecosystem wallet.
   const { partnerId } = useB3Config();
@@ -119,11 +117,26 @@ export function useUnifiedChainSwitchAndExecute() {
     [connectedEOAWallet, switchChainAsync],
   );
 
-  // Handle AA wallet transaction (no chain switch needed for AA)
-  const handleAASendTransaction = useCallback(
-    async (targetChainId: number, params: UnifiedTransactionParams): Promise<string | undefined> => {
-      if (!aaAccount) {
-        toast.error("Smart wallet not connected");
+  // Handle Global Account transaction (no chain switch needed for AA).
+  // Resolve the signer from the connected ecosystem wallet rather than the active
+  // wallet so callers can explicitly require the Global Account.
+  const handleGlobalAccountSendTransaction = useCallback(
+    async (
+      targetChainId: number,
+      params: UnifiedTransactionParams,
+      expectedGlobalAccountAddress?: string,
+    ): Promise<string | undefined> => {
+      const globalAccount = connectedSmartWallet?.getAccount();
+      if (!globalAccount) {
+        toast.error("Global Account not connected");
+        return;
+      }
+
+      if (
+        expectedGlobalAccountAddress &&
+        globalAccount.address.toLowerCase() !== expectedGlobalAccountAddress.toLowerCase()
+      ) {
+        toast.error("Connected Global Account does not match the authenticated account");
         return;
       }
 
@@ -162,7 +175,7 @@ export function useUnifiedChainSwitchAndExecute() {
         toast.info("Sending transaction…");
         const start = performance.now();
         const sendTxResponse = await twSendTransaction({
-          account: aaAccount,
+          account: globalAccount,
           transaction,
         });
         const end = performance.now();
@@ -178,7 +191,7 @@ export function useUnifiedChainSwitchAndExecute() {
         setIsSwitchingOrExecuting(false);
       }
     },
-    [aaAccount, partnerId],
+    [connectedSmartWallet, partnerId],
   );
 
   // Unified switch chain and execute function
@@ -186,15 +199,16 @@ export function useUnifiedChainSwitchAndExecute() {
     async (targetChainId: number, params: UnifiedTransactionParams): Promise<string | undefined> => {
       // Check which wallet type is active
       if (isActiveSmartWallet) {
-        return handleAASendTransaction(targetChainId, params);
+        return handleGlobalAccountSendTransaction(targetChainId, params);
       }
       return handleEOASwitchChainAndSendTransaction(targetChainId, params);
     },
-    [isActiveSmartWallet, handleAASendTransaction, handleEOASwitchChainAndSendTransaction],
+    [isActiveSmartWallet, handleGlobalAccountSendTransaction, handleEOASwitchChainAndSendTransaction],
   );
 
   return {
     switchChainAndExecute,
+    switchChainAndExecuteWithGlobalAccount: handleGlobalAccountSendTransaction,
     switchChainAndExecuteWithEOA: handleEOASwitchChainAndSendTransaction,
     isSwitchingOrExecuting,
     isActiveSmartWallet,

package/src/global-account/react/stores/useModalStore.ts

@@ -675,8 +675,6 @@ export interface AnySpendDepositModalProps extends BaseModalProps {
   showChainSelection?: boolean;
   /** Whether to show the "Fund with Fiat" option in the deposit options list. Defaults to true */
   showFiatOption?: boolean;
-  /** Minimum pool size for filtering tokens (default: 1,000,000) */
-  minPoolSize?: number;
   /** Custom title for chain selection step */
   chainSelectionTitle?: string;
   /** Custom description for chain selection step */

package/src/shared/constants/index.ts

@@ -1,3 +1,5 @@
+import type { Wallet } from "thirdweb/wallets";
+
 export * from "./currency";
 
 export const siteURL = "https://basement.fun";
@@ -8,6 +10,12 @@ export const ecosystemWalletId = (process.env.NEXT_PUBLIC_THIRDWEB_ECOSYSTEM_ID
   process.env.EXPO_PUBLIC_THIRDWEB_ECOSYSTEM_ID ||
   "ecosystem.b3-open-gaming") as `ecosystem.${string}`; // Fallback to prod key lookup
 
+// Portable equivalent of thirdweb's `EcosystemWallet`, which thirdweb does not export
+// from any public entry point — declaration emit cannot name the internal type (TS2742).
+export type EcosystemWallet = Wallet<`ecosystem.${string}`> & {
+  getAuthToken: () => string | null;
+};
+
 export const tokenIcons = {
   ETH: "https://cdn.b3.fun/ethereum.svg",
   WETH: "https://cdn.b3.fun/wrapped-ethereum.svg",

package/src/shared/utils/__tests__/zerionPositions.test.ts

@@ -0,0 +1,226 @@
+import { describe, expect, it } from "vitest";
+import {
+  adaptZerionPositions,
+  chainIdToZerionSlug,
+  EVM_NATIVE_TOKEN_ADDRESS,
+  zerionSlugToChainId,
+  type ZerionPositionLike,
+} from "../zerionPositions";
+
+// Slugs and ids below are shaped after live Zerion responses.
+const SLUG_TO_CHAIN_ID: Record<string, number> = {
+  ethereum: 1,
+  base: 8453,
+  polygon: 137,
+  celo: 42220,
+  hyperevm: 999,
+};
+const slugToChainId = (slug: string) => SLUG_TO_CHAIN_ID[slug];
+
+function position(overrides: {
+  id: string;
+  slug: string;
+  symbol: string;
+  implAddress?: string | null;
+  implDecimals?: number;
+  quantityDecimals?: number;
+  int?: string;
+}): ZerionPositionLike {
+  const { id, slug, symbol, implAddress = null, implDecimals = 18, quantityDecimals = 18, int = "1000" } = overrides;
+  return {
+    id,
+    attributes: {
+      quantity: { int, decimals: quantityDecimals },
+      fungible_info: {
+        symbol,
+        implementations: [{ chain_id: slug, address: implAddress, decimals: implDecimals }],
+      },
+    },
+    relationships: { chain: { data: { id: slug } } },
+  };
+}
+
+describe("adaptZerionPositions native detection", () => {
+  it("treats a null implementation address as the chain's native coin", () => {
+    const [row] = adaptZerionPositions(
+      [position({ id: "base-base-asset-asset", slug: "base", symbol: "ETH" })],
+      slugToChainId,
+    );
+
+    expect(row.is_native).toBe(true);
+    expect(row.address).toBe(EVM_NATIVE_TOKEN_ADDRESS);
+  });
+
+  it("treats Polygon's native coin as native despite its system-contract address", () => {
+    const [row] = adaptZerionPositions(
+      [
+        position({
+          id: "base-polygon-asset-asset",
+          slug: "polygon",
+          symbol: "POL",
+          implAddress: "0x0000000000000000000000000000000000001010",
+        }),
+      ],
+      slugToChainId,
+    );
+
+    expect(row.is_native).toBe(true);
+    expect(row.address).toBe(EVM_NATIVE_TOKEN_ADDRESS);
+  });
+
+  it("treats Celo's native coin as native despite its ERC-20 address", () => {
+    const [row] = adaptZerionPositions(
+      [
+        position({
+          id: "base-celo-asset-asset",
+          slug: "celo",
+          symbol: "celo",
+          implAddress: "0x471ece3750da237f93b8e339c536989b8978a438",
+        }),
+      ],
+      slugToChainId,
+    );
+
+    expect(row.is_native).toBe(true);
+  });
+
+  it("keeps a same-symbol non-native fungible distinct from the native coin", () => {
+    const rows = adaptZerionPositions(
+      [
+        position({
+          id: "base-polygon-asset-asset",
+          slug: "polygon",
+          symbol: "POL",
+          implAddress: "0x0000000000000000000000000000000000001010",
+        }),
+        position({
+          id: "0x89299a4c719ebe9fe6018aed81eb1d48b4f78d56-polygon-asset-asset",
+          slug: "polygon",
+          symbol: "POL",
+          implAddress: "0x89299a4c719ebe9fe6018aed81eb1d48b4f78d56",
+        }),
+      ],
+      slugToChainId,
+    );
+
+    expect(rows.map(r => r.is_native)).toEqual([true, false]);
+    expect(rows[1].address).toBe("0x89299a4c719ebe9fe6018aed81eb1d48b4f78d56");
+  });
+});
+
+describe("adaptZerionPositions row filtering", () => {
+  it("drops a row whose chain is unmapped", () => {
+    const rows = adaptZerionPositions(
+      [position({ id: "base-unknownchain-asset-asset", slug: "unknownchain", symbol: "???" })],
+      slugToChainId,
+    );
+
+    expect(rows).toEqual([]);
+  });
+
+  it("drops a row whose fungible has no implementation on its chain, rather than calling it native", () => {
+    const rows = adaptZerionPositions(
+      [
+        {
+          id: "0xabc-ethereum-asset-asset",
+          attributes: {
+            quantity: { int: "1000", decimals: 18 },
+            fungible_info: {
+              symbol: "ORPHAN",
+              // implementations exist, but none for the position's own chain
+              implementations: [{ chain_id: "polygon", address: "0xabc", decimals: 18 }],
+            },
+          },
+          relationships: { chain: { data: { id: "ethereum" } } },
+        },
+      ],
+      slugToChainId,
+    );
+
+    expect(rows).toEqual([]);
+  });
+
+  it("drops a row that carries no quantity rather than reporting a zero balance", () => {
+    const rows = adaptZerionPositions(
+      [
+        {
+          id: "base-base-asset-asset",
+          attributes: {
+            quantity: { decimals: 18 },
+            fungible_info: { symbol: "ETH", implementations: [{ chain_id: "base", address: null, decimals: 18 }] },
+          },
+          relationships: { chain: { data: { id: "base" } } },
+        },
+      ],
+      slugToChainId,
+    );
+
+    expect(rows).toEqual([]);
+  });
+
+  it("drops a row that carries no decimals rather than guessing a scale", () => {
+    const rows = adaptZerionPositions(
+      [
+        {
+          id: "0xabc-ethereum-asset-asset",
+          attributes: {
+            quantity: { int: "1000" },
+            fungible_info: { symbol: "MYSTERY", implementations: [{ chain_id: "ethereum", address: "0xabc" }] },
+          },
+          relationships: { chain: { data: { id: "ethereum" } } },
+        },
+      ],
+      slugToChainId,
+    );
+
+    expect(rows).toEqual([]);
+  });
+
+  it("drops trash and non-displayable rows", () => {
+    const base = position({ id: "0xspam-ethereum-asset-asset", slug: "ethereum", symbol: "SPAM" });
+    const spam: ZerionPositionLike = { ...base, attributes: { ...base.attributes, flags: { is_trash: true } } };
+    const hidden: ZerionPositionLike = {
+      ...base,
+      attributes: { ...base.attributes, flags: { displayable: false } },
+    };
+
+    expect(adaptZerionPositions([spam, hidden], slugToChainId)).toEqual([]);
+  });
+
+  it("drops any quantity that is not a base-10 integer, since all of them format to NaN", () => {
+    const rows = adaptZerionPositions(
+      [
+        position({ id: "0xa-ethereum-asset-asset", slug: "ethereum", symbol: "A", int: "" }),
+        position({ id: "0xb-ethereum-asset-asset", slug: "ethereum", symbol: "B", int: null as unknown as string }),
+        position({ id: "0xc-ethereum-asset-asset", slug: "ethereum", symbol: "C", int: "not-a-number" }),
+        position({ id: "0xd-ethereum-asset-asset", slug: "ethereum", symbol: "D", int: "0x1f" }),
+        position({ id: "0xe-ethereum-asset-asset", slug: "ethereum", symbol: "E", int: "1.5" }),
+      ],
+      slugToChainId,
+    );
+
+    expect(rows).toEqual([]);
+  });
+
+  it("keeps a genuine zero balance", () => {
+    const [row] = adaptZerionPositions(
+      [position({ id: "base-ethereum-asset-asset", slug: "ethereum", symbol: "ETH", int: "0" })],
+      slugToChainId,
+    );
+
+    expect(row.amount).toBe("0");
+  });
+});
+
+describe("zerionSlugToChainId", () => {
+  it("reports an inherited object key as an unknown chain", () => {
+    // Slugs come off the wire; an object lookup would answer `constructor` with a function.
+    expect(zerionSlugToChainId("constructor")).toBeUndefined();
+    expect(zerionSlugToChainId("toString")).toBeUndefined();
+  });
+
+  it("still resolves a real slug", () => {
+    expect(zerionSlugToChainId("ethereum")).toBe(1);
+    expect(chainIdToZerionSlug(8453)).toBe("base");
+  });
+});