@b3dotfun/sdk 0.1.70-alpha.2 → 0.1.70-alpha.21

package/src/shared/utils/zerionPositions.ts

@@ -0,0 +1,247 @@
+import { SOLANA_NATIVE_ASSET } from "@b3/chain-registry/runtime";
+
+/**
+ * Canonical browser-side translation of Zerion wallet positions into B3 balance rows.
+ *
+ * This lives in the published SDK because every browser consumer needs it — the apps in this repo
+ * and the sites that install `@b3dotfun/sdk` from npm — and the in-repo Zerion client is a private
+ * workspace package that a published package cannot depend on. Backend services keep their own
+ * translation: pulling a browser SDK into a Node service to share one function is a worse trade
+ * than the second copy.
+ *
+ * Only the HTTP layer differs between callers. The rules below — which row counts as the chain's
+ * native coin, and which rows have no usable identity — must not be re-derived anywhere else.
+ */
+
+/** Address B3 uses for a chain's native coin on EVM. Matches NATIVE_TOKEN_ADDRESSES. */
+export const EVM_NATIVE_TOKEN_ADDRESS = "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
+export const SOLANA_NATIVE_TOKEN_ADDRESS = SOLANA_NATIVE_ASSET.wrapped
+  .address as "So11111111111111111111111111111111111111112";
+export const SOLANA_ZERION_SLUG = SOLANA_NATIVE_ASSET.chain as "solana";
+/** What Zerion's `quantity.int` is: a base-10 integer, unbounded in length. */
+const DECIMAL_INTEGER_PATTERN = /^\d+$/;
+/** Solana's chain id as the chain registry defines it — the id every balance row is keyed by. */
+export const SOLANA_CHAIN_ID = SOLANA_NATIVE_ASSET.chainId as 7565164;
+
+/**
+ * Zerion chain slug → numeric chain id. Slugs are Zerion's own vocabulary and do not always match
+ * the chain's common name — Gnosis is `xdai`, Metis is `metis-andromeda` — so an entry invented
+ * from the chain name silently drops every position on that chain, because the adapter skips any
+ * slug it cannot map. Every entry here is taken from Zerion's `GET /v1/chains/`.
+ */
+const ZERION_CHAIN_IDS: Readonly<Record<string, number>> = {
+  ethereum: 1,
+  optimism: 10,
+  "binance-smart-chain": 56,
+  xdai: 100,
+  unichain: 130,
+  polygon: 137,
+  sonic: 146,
+  fantom: 250,
+  "zksync-era": 324,
+  world: 480,
+  hyperevm: 999,
+  "metis-andromeda": 1088,
+  "polygon-zkevm": 1101,
+  soneium: 1868,
+  ronin: 2020,
+  abstract: 2741,
+  robinhood: 4663,
+  mantle: 5000,
+  base: 8453,
+  mode: 34443,
+  arbitrum: 42161,
+  celo: 42220,
+  avalanche: 43114,
+  linea: 59144,
+  berachain: 80094,
+  blast: 81457,
+  taiko: 167000,
+  scroll: 534352,
+  zora: 7777777,
+  degen: 666666666,
+  aurora: 1313161554,
+  [SOLANA_ZERION_SLUG]: SOLANA_CHAIN_ID,
+};
+
+// Maps rather than objects: a slug arrives straight off the wire, and an object lookup resolves an
+// inherited key like `constructor` or `toString` to something truthy instead of reporting the chain
+// as unknown — which would carry a row past the `=== undefined` guard with a function as its id.
+const CHAIN_ID_BY_ZERION_SLUG: ReadonlyMap<string, number> = new Map(Object.entries(ZERION_CHAIN_IDS));
+
+const ZERION_SLUG_BY_CHAIN_ID: ReadonlyMap<number, string> = new Map(
+  Object.entries(ZERION_CHAIN_IDS).map(([slug, id]) => [id, slug]),
+);
+
+export function zerionSlugToChainId(slug: string): number | undefined {
+  return CHAIN_ID_BY_ZERION_SLUG.get(slug);
+}
+
+export function chainIdToZerionSlug(chainId: number): string | undefined {
+  return ZERION_SLUG_BY_CHAIN_ID.get(chainId);
+}
+
+export interface ZerionPositionQuantity {
+  int?: string;
+  decimals?: number;
+}
+
+export interface ZerionPositionImplementation {
+  chain_id?: string;
+  address?: string | null;
+  decimals?: number;
+}
+
+export interface ZerionPositionFungibleInfo {
+  name?: string;
+  symbol?: string;
+  icon?: { url?: string } | null;
+  implementations?: ZerionPositionImplementation[];
+}
+
+export interface ZerionPositionLike {
+  id?: string;
+  attributes?: {
+    quantity?: ZerionPositionQuantity;
+    value?: number | null;
+    price?: number | null;
+    fungible_info?: ZerionPositionFungibleInfo;
+    flags?: { displayable?: boolean; is_trash?: boolean };
+  };
+  relationships?: { chain?: { data?: { id?: string } } };
+}
+
+/** One spendable holding. `amount` is the raw integer; pair it with `decimals` to display. */
+export interface B3TokenBalance {
+  chain: string;
+  chain_id: number;
+  address: string;
+  amount: string;
+  symbol: string;
+  decimals: number;
+  /**
+   * Whether `address` is the native-coin sentinel rather than a real contract. Callers deciding
+   * between a value-bearing send and an ERC-20 `transfer` MUST branch on this, never on the
+   * sentinel string: getting it backwards spends gas and moves nothing.
+   */
+  is_native: boolean;
+  name?: string;
+  price_usd?: number;
+  value_usd?: number;
+  token_metadata?: { logo: string };
+}
+
+/**
+ * Zerion encodes a position's asset in the first hyphen-delimited segment of its resource `id`
+ * (`<assetRef>-<chainSlug>-<positionType>-…`). A chain's native coin uses the literal `base`
+ * (`base-polygon-asset-asset`); ERC-20s use the contract address
+ * (`0x1dd17…-ethereum-asset-asset`).
+ *
+ * This is the only reliable native signal. A falsy per-chain `implementation.address` looks
+ * equivalent and is not: Zerion reports Polygon's native coin at its `0x…1010` system contract and
+ * Celo's at a real ERC-20 address, while Polygon simultaneously carries a non-native fungible with
+ * the same `POL` symbol. Keying on the address shape misclassifies both.
+ */
+function isNativePosition(id: string | undefined, impl: ZerionPositionImplementation | undefined): boolean {
+  if (id?.startsWith("base-") === true) return true;
+  // Second signal, for the chains that spell native as an absent address. It requires the
+  // implementation to EXIST: a fungible with no entry for this chain tells us nothing about what
+  // the row is, and calling that native would hand a value-bearing send an amount we cannot name.
+  return impl !== undefined && !impl.address;
+}
+
+export function nativeTokenAddressForChain(slug: string): string {
+  return slug === SOLANA_ZERION_SLUG ? SOLANA_NATIVE_TOKEN_ADDRESS : EVM_NATIVE_TOKEN_ADDRESS;
+}
+
+/**
+ * Every spelling of "the chain's own coin" a caller might hold.
+ *
+ * A token record's address depends on where it came from — a quote provider, a token list, a URL
+ * parameter — and each source names the native coin differently. Matching a balance row against any
+ * single one of these silently fails for the others.
+ */
+const NATIVE_TOKEN_MARKERS: ReadonlySet<string> = new Set([
+  "native",
+  "0x0000000000000000000000000000000000000000",
+  EVM_NATIVE_TOKEN_ADDRESS,
+  SOLANA_NATIVE_TOKEN_ADDRESS.toLowerCase(),
+  "11111111111111111111111111111111",
+]);
+
+/**
+ * Whether `balance` is the token identified by `tokenAddress`.
+ *
+ * Native coins are matched on the row's `is_native` flag rather than its printed address, because
+ * the caller and the adapter rarely spell the native coin the same way.
+ */
+export function balanceMatchesToken(balance: B3TokenBalance, tokenAddress: string): boolean {
+  const wanted = tokenAddress.toLowerCase();
+  if (NATIVE_TOKEN_MARKERS.has(wanted)) return balance.is_native;
+  // Case-insensitive only for hex contract addresses. Solana mints are base58, where case is
+  // significant — lowercasing them would let two distinct mints compare equal.
+  if (balance.chain === SOLANA_ZERION_SLUG) return balance.address === tokenAddress;
+  return balance.address.toLowerCase() === wanted;
+}
+
+/**
+ * Adapt raw Zerion positions into balance rows, dropping any row we cannot describe honestly.
+ *
+ * A row is dropped when its chain slug is absent or unmapped, or when neither the quantity nor the
+ * chain implementation carries decimals — an amount rendered against a guessed scale is a wrong
+ * number presented as a real one, which is worse for the reader than a missing row.
+ *
+ * @param slugToChainId overrides slug resolution; return undefined to skip a chain entirely.
+ */
+export function adaptZerionPositions(
+  positions: ZerionPositionLike[],
+  slugToChainId: (slug: string) => number | undefined = zerionSlugToChainId,
+): B3TokenBalance[] {
+  const out: B3TokenBalance[] = [];
+
+  for (const position of positions) {
+    const attributes = position.attributes ?? {};
+    const flags = attributes.flags;
+    if (flags && (flags.displayable === false || flags.is_trash === true)) continue;
+
+    const slug = position.relationships?.chain?.data?.id;
+    if (!slug) continue;
+
+    const chainId = slugToChainId(slug);
+    if (chainId === undefined) continue;
+
+    const fungibleInfo = attributes.fungible_info ?? {};
+    const implementation = (fungibleInfo.implementations ?? []).find(entry => entry.chain_id === slug);
+
+    const decimals = attributes.quantity?.decimals ?? implementation?.decimals;
+    if (decimals === undefined) continue;
+
+    const isNative = isNativePosition(position.id, implementation);
+    // A non-native row with no contract address has no on-chain identity — drop it rather than
+    // render a holding nothing can name.
+    const address = isNative ? nativeTokenAddressForChain(slug) : implementation?.address;
+    if (!address) continue;
+
+    // A quantity we cannot read is not a zero balance. Must be the base-10 integer `quantity.int`
+    // is: `null`, `""`, and any other unusable string all format to NaN, which callers coerce back
+    // to 0 and show as "holds none". `"0"` matches, so a real zero balance still comes through.
+    const amount = attributes.quantity?.int;
+    if (amount === undefined || !DECIMAL_INTEGER_PATTERN.test(amount)) continue;
+
+    out.push({
+      chain: slug,
+      chain_id: chainId,
+      address,
+      amount,
+      symbol: fungibleInfo.symbol ?? "",
+      decimals,
+      is_native: isNative,
+      name: fungibleInfo.name,
+      price_usd: attributes.price ?? undefined,
+      value_usd: attributes.value ?? undefined,
+      token_metadata: fungibleInfo.icon?.url ? { logo: fungibleInfo.icon.url } : undefined,
+    });
+  }
+
+  return out;
+}

package/src/styles/index.css

@@ -321,6 +321,33 @@ html[data-theme="dark"] .b3-root,
   padding: 0 !important;
 }
 
+/*
+ * Relay Kit's "Unverified Token" confirmation dialog (rendered by the Relay
+ * TokenSelector inside the AnySpend modal) portals to <body> with its overlay
+ * at inline `z-index: 10001` and its content at `z-index: 1000` (inside that
+ * overlay). The AnySpend / B3 modal that hosts the TokenSelector — and the
+ * TokenSelector's own token-list overlay — get stacked at z-indexes >= 10001
+ * by host apps (b3os-web bumps `.b3-modal` to 10001 and the Relay token-list
+ * overlay to 10003), so this confirmation dialog ends up *behind* the modal it
+ * was launched from and becomes invisible / unclickable.
+ *
+ * Relay exposes no z-index theming, so force the confirmation overlay (and
+ * therefore its content, which lives inside it) above the host stack. The
+ * highest known host z-index is 10003 (b3os-web's Relay token-list overlay),
+ * so 99999 is comfortably sufficient. The `z-index: 10001` inline value is
+ * unique to Relay's UnverifiedTokenModal — its other modals (token list, etc.)
+ * default to `z-index: 9999`.
+ *
+ * NOTE: this selector is intentionally prefixed with `body` so it is NOT
+ * scoped under `.b3-root` by postcss-prefix-selector (see postcss.config.js).
+ * Relay's modal portals to <body>, OUTSIDE the `.b3-root` subtree, so a
+ * `.b3-root`-scoped rule would never match it.
+ */
+body .relay-kit-reset[style*="z-index: 10001"],
+body .relay-kit-reset[style*="z-index:10001"] {
+  z-index: 99999 !important;
+}
+
 .b3-modal-back-button:hover {
   @apply border-none !text-black;
 }

package/dist/cjs/global-account/react/components/SignInWithB3/SignInWithB3Privy.d.ts

@@ -1,10 +0,0 @@
-import type { Chain } from "thirdweb";
-import { Account } from "thirdweb/wallets";
-interface SignInWithB3PrivyProps {
-    onError?: (error: Error) => Promise<void>;
-    onSuccess: (account: Account) => Promise<void>;
-    accessToken?: string;
-    chain: Chain;
-}
-export declare function SignInWithB3Privy({ onSuccess, onError, chain }: SignInWithB3PrivyProps): import("react/jsx-runtime").JSX.Element;
-export {};

package/dist/cjs/global-account/react/components/SignInWithB3/SignInWithB3Privy.js

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SignInWithB3Privy = SignInWithB3Privy;
-const jsx_runtime_1 = require("react/jsx-runtime");
-const react_1 = require("../../../../global-account/react");
-const debug_1 = require("../../../../shared/utils/debug");
-const react_2 = require("react");
-const debug = (0, debug_1.debugB3React)("SignInWithB3Privy");
-function SignInWithB3Privy({ onSuccess, onError, chain }) {
-    const { partnerId } = (0, react_1.useB3Config)();
-    const { isLoading, connectTw, fullToken } = (0, react_1.useHandleConnectWithPrivy)(chain, onSuccess);
-    const setIsAuthenticating = (0, react_1.useAuthStore)(state => state.setIsAuthenticating);
-    const setIsAuthenticated = (0, react_1.useAuthStore)(state => state.setIsAuthenticated);
-    const { logout } = (0, react_1.useAuthentication)(partnerId, { skipAutoConnect: true });
-    debug("@@SignInWithB3Privy", {
-        isLoading,
-        fullToken,
-    });
-    (0, react_2.useEffect)(() => {
-        async function autoConnect() {
-            try {
-                const connectResult = await connectTw();
-                const account = connectResult?.getAccount();
-                if (!account) {
-                    setIsAuthenticated(false);
-                    return;
-                }
-                await onSuccess(account);
-                setIsAuthenticated(true);
-            }
-            catch (error) {
-                console.error("Failed to connect:", error);
-                await onError?.(error);
-                await logout();
-                setIsAuthenticated(false);
-            }
-            finally {
-                debug("setIsAuthenticating:false:7");
-                setIsAuthenticating(false);
-            }
-        }
-        autoConnect();
-    }, [connectTw, onSuccess, onError, setIsAuthenticated, logout, setIsAuthenticating]);
-    // Currently we auto login, so we can show loading immediately and the onSuccess will proceed to the next modal
-    return ((0, jsx_runtime_1.jsx)("div", { className: "flex aspect-square items-center justify-center p-6", children: (0, jsx_runtime_1.jsx)(react_1.Loading, { variant: "white", size: "lg" }) }));
-}

package/dist/cjs/global-account/react/hooks/useHandleConnectWithPrivy.d.ts

@@ -1,11 +0,0 @@
-import { Chain } from "thirdweb";
-import { Account } from "thirdweb/wallets";
-/**
- * This essentially wraps our useConnect hook to handle the Privy auth flow.
- * Currently, this is for the basement-privy strategy
- */
-export declare function useHandleConnectWithPrivy(chain?: Chain, onSuccess?: (account: Account) => void): {
-    connectTw: () => Promise<import("thirdweb/wallets").Wallet | null | undefined>;
-    isLoading: boolean;
-    fullToken: string | null;
-};

package/dist/cjs/global-account/react/hooks/useHandleConnectWithPrivy.js

@@ -1,70 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useHandleConnectWithPrivy = useHandleConnectWithPrivy;
-const react_1 = require("../../../global-account/react");
-const debug_1 = require("../../../shared/utils/debug");
-const react_auth_1 = require("@privy-io/react-auth");
-const react_2 = require("react");
-const debug = (0, debug_1.debugB3React)("@@b3:useHandleConnectWithPrivy");
-/**
- * This essentially wraps our useConnect hook to handle the Privy auth flow.
- * Currently, this is for the basement-privy strategy
- */
-function useHandleConnectWithPrivy(chain, onSuccess) {
-    const { partnerId } = (0, react_1.useB3Config)();
-    if (!chain) {
-        throw new Error("Chain is required");
-    }
-    const { connect } = (0, react_1.useConnect)(partnerId, chain);
-    const [isLoading, setIsLoading] = (0, react_2.useState)(true);
-    const isConnecting = (0, react_2.useRef)(false);
-    const { identityToken } = (0, react_auth_1.useIdentityToken)();
-    const { getAccessToken } = (0, react_auth_1.usePrivy)();
-    const [fullToken, setFullToken] = (0, react_2.useState)(null);
-    const connectTw = (0, react_2.useCallback)(async () => {
-        if (isConnecting.current) {
-            debug("@@connectTw:skipping:isConnecting", isConnecting.current);
-            return;
-        }
-        setIsLoading(true);
-        isConnecting.current = true;
-        // Form token
-        const accessToken = await getAccessToken();
-        const fullToken = `${accessToken}+${identityToken}`;
-        setFullToken(fullToken);
-        debug("@@connectTw:fullToken", fullToken);
-        if (!fullToken)
-            throw new Error("Token is not set");
-        // Connect to TW via privy
-        const wallet = await connect({
-            strategy: "auth_endpoint",
-            payload: JSON.stringify({
-                strategy: "basement",
-                accessToken: fullToken,
-            }),
-        });
-        debug("@@useHandleConnectWithPrivy:connect:return", wallet);
-        setIsLoading(false);
-        // Handle onsuccess & more
-        try {
-            debug("@@autoLogin:starting", fullToken);
-            const account = wallet?.getAccount();
-            if (!account) {
-                throw new Error("Failed to connect");
-            }
-            onSuccess?.(account);
-            if (!account) {
-                throw new Error("Failed to connect");
-            }
-        }
-        catch (error) {
-            console.error("@@Error signing in with Privy", error);
-        }
-        finally {
-            isConnecting.current = false;
-            setIsLoading(false);
-        }
-        return wallet;
-    }, [connect, getAccessToken, identityToken, onSuccess]);
-    return { connectTw, isLoading, fullToken };
-}

package/dist/cjs/global-account/react/hooks/useSimBalance.d.ts

@@ -1,59 +0,0 @@
-export interface SimTokenMetadata {
-    logo?: string;
-}
-export interface SimBalanceItem {
-    chain: string;
-    chain_id: number;
-    address: string;
-    amount: string;
-    symbol: string;
-    decimals: number;
-    price_usd?: number;
-    value_usd?: number;
-    name?: string;
-    token_metadata?: SimTokenMetadata;
-    pool_size?: number;
-    low_liquidity?: boolean;
-}
-export interface SimBalanceResponse {
-    request_time: string;
-    response_time: string;
-    wallet_address: string;
-    balances: SimBalanceItem[];
-}
-export interface SvmBalanceItem {
-    chain: string;
-    address: string;
-    amount: string;
-    balance: string;
-    raw_balance: string;
-    value_usd?: number;
-    program_id: string | null;
-    decimals: number;
-    total_supply: string;
-    metadata_address?: string;
-    name?: string;
-    symbol: string;
-    uri?: string | null;
-    price_usd?: number;
-    liquidity_usd?: number;
-    pool_type?: string | null;
-    pool_address?: string | null;
-    mint_authority?: string | null;
-}
-export interface SvmBalanceResponse {
-    processing_time_ms?: number;
-    wallet_address: string;
-    next_offset?: string;
-    balances_count?: number;
-    balances: SvmBalanceItem[];
-}
-export declare function useSimBalance(address?: string, chainIdsParam?: number[]): import("@tanstack/react-query").UseQueryResult<SimBalanceResponse, Error>;
-export declare function useSimSvmBalance(address?: string, chains?: ("solana" | "eclipse")[], limit?: number): import("@tanstack/react-query").UseQueryResult<SvmBalanceResponse, Error>;
-/**
- * Hook to fetch a single token balance for a wallet.
- * @param walletAddress - The wallet address to fetch balance for
- * @param tokenAddress - The token contract address, or "native" for native token (ETH, etc.)
- * @param chainId - Chain ID to query (defaults to 1 for Ethereum mainnet)
- */
-export declare function useSimTokenBalance(walletAddress?: string, tokenAddress?: string, chainId?: number): import("@tanstack/react-query").UseQueryResult<SimBalanceResponse, Error>;

package/dist/cjs/global-account/react/hooks/useSimBalance.js

@@ -1,98 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useSimBalance = useSimBalance;
-exports.useSimSvmBalance = useSimSvmBalance;
-exports.useSimTokenBalance = useSimTokenBalance;
-const react_query_1 = require("@tanstack/react-query");
-const simdune_1 = require("../utils/simdune");
-async function fetchSimBalance(address, chainIdsParam) {
-    if (!address)
-        throw new Error("Address is required");
-    const chainIds = chainIdsParam.length === 0 ? "mainnet" : chainIdsParam.join(",");
-    const queryParams = new URLSearchParams();
-    queryParams.append("metadata", "logo");
-    queryParams.append("chain_ids", chainIds);
-    queryParams.append("exclude_spam_tokens", "true");
-    const url = (0, simdune_1.buildSimduneUrl)(`/v1/evm/balances/${address}`, queryParams);
-    const response = await fetch(url);
-    if (!response.ok) {
-        throw new Error(`Failed to fetch balance: ${response.statusText}`);
-    }
-    const balanceData = await response.json();
-    return balanceData;
-}
-async function fetchSimTokenBalance(walletAddress, tokenAddress, chainId) {
-    if (!walletAddress)
-        throw new Error("Wallet address is required");
-    if (!tokenAddress)
-        throw new Error("Token address is required");
-    if (!chainId)
-        throw new Error("Chain ID is required");
-    const queryParams = new URLSearchParams();
-    queryParams.append("chain_ids", chainId.toString());
-    const url = (0, simdune_1.buildSimduneUrl)(`/v1/evm/balances/${walletAddress}/token/${tokenAddress}`, queryParams);
-    const response = await fetch(url);
-    if (!response.ok) {
-        throw new Error(`Failed to fetch token balance: ${response.statusText}`);
-    }
-    const balanceData = await response.json();
-    return balanceData;
-}
-async function fetchSimSvmBalance(address, chains, limit) {
-    if (!address)
-        throw new Error("Address is required");
-    const queryParams = new URLSearchParams();
-    if (chains && chains.length > 0) {
-        queryParams.append("chains", chains.join(","));
-    }
-    if (limit) {
-        queryParams.append("limit", limit.toString());
-    }
-    const url = (0, simdune_1.buildSimduneUrl)(`/beta/svm/balances/${address}`, queryParams.toString() ? queryParams : undefined);
-    const response = await fetch(url);
-    if (!response.ok) {
-        throw new Error(`Failed to fetch SVM balance: ${response.statusText}`);
-    }
-    const balanceData = await response.json();
-    return balanceData;
-}
-function useSimBalance(address, chainIdsParam) {
-    return (0, react_query_1.useQuery)({
-        queryKey: ["simBalance", address, chainIdsParam],
-        queryFn: () => {
-            if (!address)
-                throw new Error("Address is required");
-            return fetchSimBalance(address, chainIdsParam || []);
-        },
-        enabled: Boolean(address),
-    });
-}
-function useSimSvmBalance(address, chains, limit) {
-    return (0, react_query_1.useQuery)({
-        queryKey: ["svmBalance", address, chains, limit],
-        queryFn: () => {
-            if (!address)
-                throw new Error("Address is required");
-            return fetchSimSvmBalance(address, chains, limit);
-        },
-        enabled: Boolean(address),
-    });
-}
-/**
- * Hook to fetch a single token balance for a wallet.
- * @param walletAddress - The wallet address to fetch balance for
- * @param tokenAddress - The token contract address, or "native" for native token (ETH, etc.)
- * @param chainId - Chain ID to query (defaults to 1 for Ethereum mainnet)
- */
-function useSimTokenBalance(walletAddress, tokenAddress, chainId) {
-    return (0, react_query_1.useQuery)({
-        queryKey: ["simTokenBalance", walletAddress, tokenAddress, chainId],
-        queryFn: () => {
-            if (!walletAddress || !tokenAddress || !chainId) {
-                throw new Error("Missing required parameters");
-            }
-            return fetchSimTokenBalance(walletAddress, tokenAddress, chainId);
-        },
-        enabled: Boolean(walletAddress) && Boolean(tokenAddress),
-    });
-}

package/dist/cjs/global-account/react/hooks/useSimCollectibles.d.ts

@@ -1,45 +0,0 @@
-import type { SimpleHashNFTResponse } from "../../../global-account/types/simplehash.types";
-export interface SimCollectibleMetadata {
-    uri: string;
-    attributes?: Array<{
-        trait_type: string;
-        value: string;
-        display_type?: string | null;
-    }>;
-}
-export interface SimCollectibleEntry {
-    contract_address: string;
-    token_standard: "ERC721" | "ERC1155";
-    token_id: string;
-    chain: string;
-    chain_id: number;
-    name?: string;
-    description?: string;
-    symbol?: string;
-    image_url?: string;
-    last_sale_price?: string;
-    metadata?: SimCollectibleMetadata;
-    is_spam?: boolean;
-    spam_score?: number;
-    explanations?: string[];
-    balance?: string;
-    last_acquired?: string;
-}
-export interface SimCollectiblesResponse {
-    address: string;
-    entries: SimCollectibleEntry[];
-    next_offset?: string;
-    request_time: string;
-    response_time: string;
-}
-/**
- * Hook to fetch NFT collectibles from Simdune API.
- * Returns data in SimpleHash format for compatibility with AccountAssets component.
- * @param address - Wallet address to fetch collectibles for
- * @param chainIdsParam - Optional array of chain IDs to filter by
- * @param options - Optional parameters (limit, filterSpam)
- */
-export declare function useSimCollectibles(address?: string, chainIdsParam?: number[], options?: {
-    limit?: number;
-    filterSpam?: boolean;
-}): import("@tanstack/react-query").UseQueryResult<SimpleHashNFTResponse, Error>;