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

package/node_modules/@b3/chain-registry/src/index.ts

@@ -1,169 +0,0 @@
-import chainsData from "../chains.json";
-
-export interface ManualToken {
-  address: `0x${string}`;
-  symbol: string;
-  decimals: number;
-  name: string;
-  logoUrl?: string;
-}
-
-/**
- * Known integration tags that can appear in `ChainDefinition.integrations`.
- * Adding a new integration → extend this union. Consumers calling
- * `chainsByIntegration("foo")` get autocomplete + typo safety.
- */
-export type KnownIntegration =
-  | "aerodrome"
-  | "anyspend"
-  | "cow-swap"
-  | "evm-log"
-  | "morpho"
-  | "railgun"
-  | "x402"
-  | "zerodev";
-
-export interface ChainDefinition {
-  chainId: number;
-  key: string;
-  name: string;
-  network: string;
-  type: "evm" | "solana";
-  isTestnet: boolean;
-  integrations: KnownIntegration[];
-  nativeCurrency: {
-    name: string;
-    symbol: string;
-    decimals: number;
-  };
-  explorer: string;
-  rpcEnvKey: string | null;
-  fallbackRpc: string | null;
-  quicknodeSlug: string | null;
-  quicknodeRpcPath?: string;
-  coingecko: {
-    platform: string;
-    nativeCoinId: string;
-  } | null;
-  /**
-   * GeckoTerminal network slug (differs from `coingecko.platform`: GT uses
-   * "eth", CoinGecko uses "ethereum"). Used for on-chain pool lookups and
-   * OHLCV charts. Null when GeckoTerminal does not index this chain.
-   */
-  geckoTerminalNetwork?: string | null;
-  trustwalletSlug: string | null;
-  logoUrl: string | null;
-  tags: string[];
-  manualTokens?: ManualToken[];
-  /**
-   * Wrapped-native ERC20 address (e.g. WETH on Ethereum, WPLUME on Plume).
-   * Used for GeckoTerminal pool lookups on the native coin and for DEX
-   * routing that needs an ERC20 form of the gas token.
-   */
-  wrappedNative?: `0x${string}`;
-}
-
-export const chains: ChainDefinition[] = chainsData as ChainDefinition[];
-
-export const evmChains = chains.filter(c => c.type === "evm");
-
-export const chainById = new Map(chains.map(c => [c.chainId, c]));
-
-export const CHAIN_IDS: Record<string, number> = Object.fromEntries(chains.map(c => [c.key, c.chainId]));
-
-export const CHAIN_NAMES: Record<number, string> = Object.fromEntries(chains.map(c => [c.chainId, c.name]));
-
-export const CHAIN_ID_TO_NETWORK: Record<number, string> = Object.fromEntries(chains.map(c => [c.chainId, c.network]));
-
-export const FALLBACK_RPC_URLS: Record<number, string> = Object.fromEntries(
-  chains.filter(c => c.fallbackRpc).map(c => [c.chainId, c.fallbackRpc!]),
-);
-
-export const BLOCK_EXPLORERS: Record<number, string> = Object.fromEntries(chains.map(c => [c.chainId, c.explorer]));
-
-export const COINGECKO_MAPPINGS: Record<number, { platform: string; nativeCoinId: string }> = Object.fromEntries(
-  chains.filter(c => c.coingecko).map(c => [c.chainId, c.coingecko!]),
-);
-
-export const TRUSTWALLET_SLUGS: Record<number, string> = Object.fromEntries(
-  chains.filter(c => c.trustwalletSlug).map(c => [c.chainId, c.trustwalletSlug!]),
-);
-
-export const CHAIN_TAG_MAP: Record<string, number> = Object.fromEntries(
-  chains.flatMap(c => c.tags.map(tag => [tag, c.chainId])),
-);
-
-export const LOGO_URLS: Record<number, string> = Object.fromEntries(
-  chains.filter(c => c.logoUrl).map(c => [c.chainId, c.logoUrl!]),
-);
-
-export function buildQuicknodeUrl(subdomain: string, key: string, chain: ChainDefinition): string | null {
-  if (chain.quicknodeSlug === null) return null;
-  const network = chain.quicknodeSlug === "" ? "" : `.${chain.quicknodeSlug}`;
-  const path = chain.quicknodeRpcPath ?? "";
-  return `https://${subdomain}${network}.quiknode.pro/${key}${path}`;
-}
-
-export function buildQuicknodeRpcMap(subdomain: string, key: string): Record<number, string> {
-  return Object.fromEntries(
-    chains.filter(c => c.quicknodeSlug !== null).map(c => [c.chainId, buildQuicknodeUrl(subdomain, key, c)!]),
-  );
-}
-
-export function chainsByIntegration(integration: KnownIntegration): ChainDefinition[] {
-  return chains.filter(c => c.integrations.includes(integration));
-}
-
-export function chainIdsByIntegration(integration: KnownIntegration): number[] {
-  return chainsByIntegration(integration).map(c => c.chainId);
-}
-
-export function chainNamesByIntegration(integration: KnownIntegration): Record<number, string> {
-  return Object.fromEntries(chainsByIntegration(integration).map(c => [c.chainId, c.name]));
-}
-
-export const ZERODEV_SUPPORTED_CHAINS: ChainDefinition[] = chainsByIntegration("zerodev");
-
-/**
- * Chains tagged with the "anyspend" integration AND of EVM type — the set
- * consumed by SDK `supportedChains` / `supportedChainsTW` for AnySpend's
- * wallet-switch gate (`useUnifiedChainSwitchAndExecute`). Solana (also tagged
- * anyspend) is excluded here because it's handled by Phantom-based flows that
- * key off `RELAY_SOLANA_MAINNET_CHAIN_ID`, not viem.
- */
-export const ANYSPEND_EVM_CHAINS: ChainDefinition[] = chainsByIntegration("anyspend").filter(c => c.type === "evm");
-
-// Validate at module init: every anyspend EVM chain must have a fallbackRpc.
-// The SDK transformers (toViemChain / toThirdwebChain) assume this invariant
-// holds — catching a missing RPC here is far better than throwing on first
-// pay-button click in production.
-{
-  const missingRpc = ANYSPEND_EVM_CHAINS.filter(c => !c.fallbackRpc);
-  if (missingRpc.length > 0) {
-    throw new Error(
-      `chain-registry: anyspend EVM chains missing fallbackRpc: ${missingRpc.map(c => `${c.chainId} (${c.key})`).join(", ")}`,
-    );
-  }
-}
-
-/**
- * Chain IDs that the default indexer (Sim Dune) does not support.
- * These chains require RPC + CoinGecko fallback for balance/metadata.
- */
-export const MANUAL_CHAIN_IDS: ReadonlySet<number> = new Set(
-  chains.filter(c => c.manualTokens && c.manualTokens.length > 0).map(c => c.chainId),
-);
-
-export function hasManualTokens(chainId: number): boolean {
-  return MANUAL_CHAIN_IDS.has(chainId);
-}
-
-export function getManualTokens(chainId: number): ManualToken[] {
-  return chainById.get(chainId)?.manualTokens ?? [];
-}
-
-export function findManualToken(chainId: number, address: string): ManualToken | null {
-  const lower = address.toLowerCase();
-  const tokens = getManualTokens(chainId);
-  return tokens.find(t => t.address.toLowerCase() === lower) ?? null;
-}

package/node_modules/@b3/chain-registry/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "declaration": true,
-    "declarationMap": true,
-    "resolveJsonModule": true,
-    "outDir": "./dist",
-    "rootDir": "./src"
-  },
-  "include": ["src/**/*"]
-}

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

@@ -1,164 +0,0 @@
-import { useQuery } from "@tanstack/react-query";
-import { buildSimduneUrl } from "../utils/simdune";
-
-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[];
-}
-
-// SVM-specific types
-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[];
-}
-
-async function fetchSimBalance(address: string, chainIdsParam: number[]): Promise<SimBalanceResponse> {
-  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 = 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: SimBalanceResponse = await response.json();
-  return balanceData;
-}
-
-async function fetchSimTokenBalance(
-  walletAddress: string,
-  tokenAddress: string,
-  chainId: number,
-): Promise<SimBalanceResponse> {
-  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 = 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: SimBalanceResponse = await response.json();
-  return balanceData;
-}
-
-async function fetchSimSvmBalance(address: string, chains?: string[], limit?: number): Promise<SvmBalanceResponse> {
-  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 = 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: SvmBalanceResponse = await response.json();
-  return balanceData;
-}
-
-export function useSimBalance(address?: string, chainIdsParam?: number[]) {
-  return useQuery({
-    queryKey: ["simBalance", address, chainIdsParam],
-    queryFn: () => {
-      if (!address) throw new Error("Address is required");
-      return fetchSimBalance(address, chainIdsParam || []);
-    },
-    enabled: Boolean(address),
-  });
-}
-
-export function useSimSvmBalance(address?: string, chains?: ("solana" | "eclipse")[], limit?: number) {
-  return 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)
- */
-export function useSimTokenBalance(walletAddress?: string, tokenAddress?: string, chainId?: number) {
-  return 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/src/global-account/react/hooks/useSimCollectibles.ts

@@ -1,238 +0,0 @@
-import type { NFT, SimpleHashNFTResponse } from "@b3dotfun/sdk/global-account/types/simplehash.types";
-import { useQuery } from "@tanstack/react-query";
-import { buildSimduneUrl } from "../utils/simdune";
-
-/**
- * Safely parse a balance string to a number, capping at MAX_SAFE_INTEGER
- * to prevent overflow issues with large ERC1155 balances.
- */
-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);
-}
-
-// Simdune Collectibles 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;
-}
-
-async function fetchSimCollectibles(
-  address: string,
-  chainIdsParam?: number[],
-  options?: { limit?: number; filterSpam?: boolean },
-): Promise<SimCollectiblesResponse> {
-  if (!address) throw new Error("Address is required");
-
-  const queryParams = new URLSearchParams();
-  if (chainIdsParam && chainIdsParam.length > 0) {
-    queryParams.append("chain_ids", chainIdsParam.join(","));
-  }
-  if (options?.limit) {
-    queryParams.append("limit", options.limit.toString());
-  }
-  if (options?.filterSpam !== undefined) {
-    queryParams.append("filter_spam", options.filterSpam.toString());
-  }
-
-  const url = buildSimduneUrl(`/v1/evm/collectibles/${address}`, queryParams);
-  const response = await fetch(url);
-
-  if (!response.ok) {
-    throw new Error(`Failed to fetch collectibles: ${response.statusText}`);
-  }
-
-  const data: SimCollectiblesResponse = await response.json();
-  return data;
-}
-
-/**
- * Transforms Simdune collectibles response to SimpleHash NFT format
- * for compatibility with existing AccountAssets component
- */
-function transformToSimpleHashFormat(data: SimCollectiblesResponse): SimpleHashNFTResponse {
-  const nfts: NFT[] = data.entries.map(entry => ({
-    nft_id: `${entry.chain}.${entry.contract_address}.${entry.token_id}`,
-    chain: entry.chain,
-    contract_address: entry.contract_address,
-    token_id: entry.token_id,
-    name: entry.name || "",
-    description: entry.description || "",
-    previews: {
-      image_small_url: entry.image_url || "",
-      image_medium_url: entry.image_url || "",
-      image_large_url: entry.image_url || "",
-      image_opengraph_url: entry.image_url || "",
-      blurhash: "",
-      predominant_color: "",
-    },
-    image_url: entry.image_url || "",
-    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: data.address,
-        quantity: safeParseBalance(entry.balance),
-        quantity_string: entry.balance || "1",
-        first_acquired_date: entry.last_acquired || "",
-        last_acquired_date: entry.last_acquired || "",
-      },
-    ],
-    contract: {
-      type: entry.token_standard,
-      name: entry.name || "",
-      symbol: entry.symbol || null,
-      deployed_by: "",
-      deployed_via_contract: "",
-      owned_by: "",
-      has_multiple_collections: false,
-    },
-    collection: {
-      collection_id: entry.contract_address,
-      name: entry.symbol || "Unknown Collection",
-      description: null,
-      image_url: entry.image_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: [entry.chain],
-      top_contracts: [entry.contract_address],
-      collection_royalties: [],
-    },
-    last_sale: entry.last_sale_price
-      ? {
-          price: entry.last_sale_price,
-        }
-      : null,
-    primary_sale: null,
-    first_created: {
-      minted_to: data.address,
-      quantity: 1,
-      quantity_string: "1",
-      timestamp: "",
-      block_number: 0,
-      transaction: "",
-      transaction_initiator: "",
-    },
-    rarity: {
-      rank: null,
-      score: null,
-      unique_attributes: null,
-    },
-    royalty: [],
-    extra_metadata: {
-      attributes: (entry.metadata?.attributes || []).map(attr => ({
-        trait_type: attr.trait_type,
-        value: attr.value,
-        display_type: attr.display_type ?? null,
-      })),
-      image_original_url: entry.image_url || "",
-      animation_original_url: null,
-      metadata_original_url: entry.metadata?.uri || "",
-    },
-  }));
-
-  return {
-    next_cursor: data.next_offset || null,
-    next: null,
-    previous: null,
-    nfts,
-  };
-}
-
-/**
- * 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 function useSimCollectibles(
-  address?: string,
-  chainIdsParam?: number[],
-  options?: { limit?: number; filterSpam?: boolean },
-) {
-  return useQuery({
-    queryKey: ["simCollectibles", address, chainIdsParam, options],
-    queryFn: async () => {
-      if (!address) throw new Error("Address is required");
-      const data = await fetchSimCollectibles(address, chainIdsParam, options);
-      return transformToSimpleHashFormat(data);
-    },
-    enabled: Boolean(address),
-    staleTime: 30 * 1000,
-    gcTime: 5 * 60 * 1000,
-  });
-}

package/src/global-account/react/utils/simdune.ts

@@ -1,20 +0,0 @@
-export const SIMDUNE_API_HOST = "https://simdune-api.sean-430.workers.dev";
-
-/**
- * Builds a Simdune API URL with the proxy wrapper and optional dev mode key.
- * @param endpoint - The Simdune API endpoint (e.g., "/v1/evm/balances/0x...")
- * @param queryParams - Optional URLSearchParams to append
- */
-export function buildSimduneUrl(endpoint: string, queryParams?: URLSearchParams): string {
-  const baseUrl = `${SIMDUNE_API_HOST}/?url=https://api.sim.dune.com${endpoint}`;
-
-  let url = baseUrl;
-  if (queryParams && queryParams.toString()) {
-    url += `?${queryParams.toString()}`;
-  }
-  if (process.env.NEXT_PUBLIC_DEVMODE_SHARED_SECRET) {
-    url += `${queryParams?.toString() ? "&" : "?"}localkey=${process.env.NEXT_PUBLIC_DEVMODE_SHARED_SECRET}`;
-  }
-
-  return url;
-}