@one_deploy/sdk 1.0.0

package/src/config/index.ts

@@ -0,0 +1,299 @@
+/**
+ * ONE SDK Configuration
+ *
+ * Chain data is fetched from ONE Engine API - no duplicates needed here.
+ * Engine is the single source of truth for 200+ EVM chains.
+ */
+
+import type { ChainConfig } from '../types';
+
+// ===== SDK Configuration =====
+export interface OneConfig {
+  // ONE Engine (required)
+  oneEngineUrl: string;
+  oneClientId: string;
+  oneSecretKey?: string; // Only for backend usage
+
+  // Optional: Direct Supabase access (for realtime subscriptions)
+  supabaseUrl?: string;
+  supabaseAnonKey?: string;
+
+  // Deprecated: Use ONE Engine instead
+  thirdwebClientId?: string;
+}
+
+let config: OneConfig | null = null;
+
+export function initOneSDK(options: OneConfig): void {
+  if (!options.oneEngineUrl) {
+    throw new Error('oneEngineUrl is required');
+  }
+  if (!options.oneClientId) {
+    throw new Error('oneClientId is required');
+  }
+  config = options;
+}
+
+export function getConfig(): OneConfig {
+  if (!config) {
+    throw new Error('ONE SDK not initialized. Call initOneSDK() first.');
+  }
+  return config;
+}
+
+export function isInitialized(): boolean {
+  return config !== null;
+}
+
+export function getEngineUrl(): string {
+  return config?.oneEngineUrl || process.env.NEXT_PUBLIC_ONE_ENGINE_URL || 'http://localhost:4000/api';
+}
+
+// ===== Chain Data (Fetched from Engine) =====
+
+// Cache for chain data
+let chainsCache: ChainConfig[] | null = null;
+let chainsCacheTimestamp = 0;
+const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
+
+/**
+ * Fetch chains from ONE Engine API
+ * Engine is the source of truth for 200+ EVM chains
+ */
+export async function fetchChains(options?: {
+  category?: 'mainnet' | 'l2' | 'testnet' | 'gaming' | 'recommended';
+  smartWallet?: boolean;
+  limit?: number;
+}): Promise<ChainConfig[]> {
+  const engineUrl = getEngineUrl();
+  const params = new URLSearchParams();
+
+  if (options?.category) params.set('category', options.category);
+  if (options?.smartWallet) params.set('smartWallet', 'true');
+  if (options?.limit) params.set('limit', options.limit.toString());
+
+  const response = await fetch(`${engineUrl}/v1/chains?${params}`);
+  const data = await response.json();
+
+  if (!data.success) {
+    throw new Error(data.error?.message || 'Failed to fetch chains');
+  }
+
+  // Transform Engine response to SDK ChainConfig format
+  return data.data.chains.map((chain: any) => ({
+    id: chain.id,
+    name: chain.name,
+    shortName: chain.shortName || chain.slug || chain.name.toLowerCase(),
+    icon: getChainIcon(chain.id),
+    nativeCurrency: chain.nativeCurrency,
+    rpcUrls: Array.isArray(chain.rpc) ? chain.rpc : [chain.rpc],
+    blockExplorerUrls: chain.blockExplorer ? [chain.blockExplorer] : [],
+    testnet: chain.testnet,
+  }));
+}
+
+/**
+ * Get all supported chains (cached)
+ */
+export async function getChains(): Promise<ChainConfig[]> {
+  const now = Date.now();
+  if (chainsCache && (now - chainsCacheTimestamp) < CACHE_TTL) {
+    return chainsCache;
+  }
+
+  chainsCache = await fetchChains({ limit: 200 });
+  chainsCacheTimestamp = now;
+  return chainsCache;
+}
+
+/**
+ * Get chain by ID
+ */
+export async function getChainById(chainId: number): Promise<ChainConfig | undefined> {
+  const chains = await getChains();
+  return chains.find(c => c.id === chainId);
+}
+
+/**
+ * Get chain by name/shortName
+ */
+export async function getChainByName(name: string): Promise<ChainConfig | undefined> {
+  const chains = await getChains();
+  const lowerName = name.toLowerCase();
+  return chains.find(
+    c => c.name.toLowerCase() === lowerName || c.shortName.toLowerCase() === lowerName
+  );
+}
+
+/**
+ * Get recommended chains for UI display
+ */
+export async function getRecommendedChains(): Promise<ChainConfig[]> {
+  return fetchChains({ category: 'recommended', limit: 10 });
+}
+
+/**
+ * Get chains with smart wallet support
+ */
+export async function getSmartWalletChains(): Promise<ChainConfig[]> {
+  return fetchChains({ smartWallet: true, limit: 50 });
+}
+
+// ===== Default Chain Constants =====
+// These are commonly used chain IDs, but full data should be fetched from Engine
+
+export const CHAIN_IDS = {
+  ETHEREUM: 1,
+  POLYGON: 137,
+  BSC: 56,
+  ARBITRUM: 42161,
+  OPTIMISM: 10,
+  BASE: 8453,
+  AVALANCHE: 43114,
+  ZKSYNC: 324,
+  LINEA: 59144,
+  SCROLL: 534352,
+  BLAST: 81457,
+  // Testnets
+  SEPOLIA: 11155111,
+  BASE_SEPOLIA: 84532,
+  ARBITRUM_SEPOLIA: 421614,
+} as const;
+
+export const DEFAULT_CHAIN_ID = CHAIN_IDS.BASE;
+
+// ===== Chain Icons (Simple emoji fallback) =====
+const CHAIN_ICONS: Record<number, string> = {
+  1: '\u229F', // Ethereum
+  137: '\uD83D\uDFE3', // Polygon
+  56: '\uD83D\uDFE1', // BSC
+  42161: '\uD83D\uDD35', // Arbitrum
+  10: '\uD83D\uDD34', // Optimism
+  8453: '\uD83D\uDD37', // Base
+  43114: '\uD83D\uDD3A', // Avalanche
+  324: '\u26A1', // zkSync
+  59144: '\uD83D\uDD39', // Linea
+  534352: '\uD83D\uDCDC', // Scroll
+};
+
+function getChainIcon(chainId: number): string {
+  return CHAIN_ICONS[chainId] || '\uD83D\uDD17';
+}
+
+// ===== Token Names Mapping =====
+// Common token symbols to human-readable names
+export const TOKEN_NAMES: Record<string, string> = {
+  ETH: 'Ethereum',
+  BTC: 'Bitcoin',
+  BNB: 'BNB',
+  MATIC: 'Polygon',
+  POL: 'Polygon',
+  AVAX: 'Avalanche',
+  USDT: 'Tether',
+  USDC: 'USD Coin',
+  DAI: 'Dai',
+  WBTC: 'Wrapped Bitcoin',
+  WETH: 'Wrapped Ether',
+  ARB: 'Arbitrum',
+  OP: 'Optimism',
+  LINK: 'Chainlink',
+  UNI: 'Uniswap',
+  AAVE: 'Aave',
+  CRV: 'Curve',
+  MKR: 'Maker',
+  SNX: 'Synthetix',
+  COMP: 'Compound',
+  SUSHI: 'SushiSwap',
+  YFI: 'Yearn Finance',
+  SOL: 'Solana',
+  DOT: 'Polkadot',
+  ATOM: 'Cosmos',
+  NEAR: 'Near Protocol',
+};
+
+// ===== CoinGecko ID Mapping =====
+// For price lookups via CoinGecko API
+export const COINGECKO_IDS: Record<string, string> = {
+  ETH: 'ethereum',
+  BTC: 'bitcoin',
+  BNB: 'binancecoin',
+  MATIC: 'matic-network',
+  POL: 'matic-network',
+  AVAX: 'avalanche-2',
+  USDT: 'tether',
+  USDC: 'usd-coin',
+  DAI: 'dai',
+  WBTC: 'wrapped-bitcoin',
+  WETH: 'weth',
+  ARB: 'arbitrum',
+  OP: 'optimism',
+  LINK: 'chainlink',
+  UNI: 'uniswap',
+  AAVE: 'aave',
+  SOL: 'solana',
+};
+
+// ===== Backwards Compatibility =====
+// @deprecated - Use getChains() or fetch from Engine API
+// These static configs are kept for backwards compatibility only
+
+export const CHAIN_CONFIGS: Record<string, ChainConfig> = {
+  ethereum: {
+    id: 1,
+    name: 'Ethereum',
+    shortName: 'ETH',
+    icon: '\u229F',
+    nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+    rpcUrls: ['https://ethereum.rpc.thirdweb.com'],
+    blockExplorerUrls: ['https://etherscan.io'],
+    testnet: false,
+  },
+  polygon: {
+    id: 137,
+    name: 'Polygon',
+    shortName: 'MATIC',
+    icon: '\uD83D\uDFE3',
+    nativeCurrency: { name: 'POL', symbol: 'POL', decimals: 18 },
+    rpcUrls: ['https://polygon.rpc.thirdweb.com'],
+    blockExplorerUrls: ['https://polygonscan.com'],
+    testnet: false,
+  },
+  base: {
+    id: 8453,
+    name: 'Base',
+    shortName: 'BASE',
+    icon: '\uD83D\uDD37',
+    nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+    rpcUrls: ['https://base.rpc.thirdweb.com'],
+    blockExplorerUrls: ['https://basescan.org'],
+    testnet: false,
+  },
+  arbitrum: {
+    id: 42161,
+    name: 'Arbitrum One',
+    shortName: 'ARB',
+    icon: '\uD83D\uDD35',
+    nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+    rpcUrls: ['https://arbitrum.rpc.thirdweb.com'],
+    blockExplorerUrls: ['https://arbiscan.io'],
+    testnet: false,
+  },
+  optimism: {
+    id: 10,
+    name: 'Optimism',
+    shortName: 'OP',
+    icon: '\uD83D\uDD34',
+    nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+    rpcUrls: ['https://optimism.rpc.thirdweb.com'],
+    blockExplorerUrls: ['https://optimistic.etherscan.io'],
+    testnet: false,
+  },
+};
+
+// @deprecated - Use getChains() to get all supported chains
+export const SUPPORTED_CHAINS = Object.keys(CHAIN_CONFIGS);
+
+// @deprecated - Use getChainByName() instead
+export function getChainConfig(chain: string): ChainConfig | undefined {
+  return CHAIN_CONFIGS[chain.toLowerCase()];
+}

package/src/hooks/index.ts

@@ -0,0 +1,2 @@
+export { useWalletBalance } from './useWalletBalance';
+export { useTokenPrice, useTokenPrices } from './useTokenPrice';

package/src/hooks/useTokenPrice.ts

@@ -0,0 +1,162 @@
+import { useState, useEffect, useCallback, useRef } from 'react';
+import { createOneEngineClient } from '../services/engine';
+import type { TokenPrice } from '../types';
+
+interface UseTokenPriceOptions {
+  autoRefresh?: boolean;
+  refreshInterval?: number;
+  engineUrl?: string;
+  clientId?: string;
+}
+
+interface UseTokenPriceReturn {
+  price: TokenPrice | null;
+  isLoading: boolean;
+  error: string | null;
+  refetch: () => Promise<void>;
+}
+
+/**
+ * Hook for fetching token price via ONE Engine
+ *
+ * Note: If using OneProvider, prefer useOneEngine().getTokenPrices() instead.
+ * This hook is for standalone usage outside of OneProvider.
+ */
+export function useTokenPrice(
+  symbol: string,
+  options: UseTokenPriceOptions = {}
+): UseTokenPriceReturn {
+  const { autoRefresh = false, refreshInterval = 30000, engineUrl, clientId } = options;
+
+  const [price, setPrice] = useState<TokenPrice | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const engineRef = useRef(createOneEngineClient({
+    baseUrl: engineUrl,
+    clientId: clientId,
+  }));
+
+  const fetchPrice = useCallback(async () => {
+    if (!symbol) return;
+
+    setIsLoading(true);
+    setError(null);
+
+    try {
+      const result = await engineRef.current.getTokenPrices([symbol]);
+      if (result.success && result.data && result.data[symbol]) {
+        const priceData = result.data[symbol];
+        setPrice({
+          symbol,
+          price: priceData.price,
+          change24h: priceData.change24h,
+          changePercent24h: priceData.change24h, // Same as change24h for percentage
+          marketCap: priceData.marketCap,
+          volume24h: 0, // Not provided by engine
+          updatedAt: new Date().toISOString(),
+        });
+      } else {
+        setError(result.error?.message || 'Failed to fetch price');
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to fetch price');
+    } finally {
+      setIsLoading(false);
+    }
+  }, [symbol]);
+
+  useEffect(() => {
+    fetchPrice();
+  }, [fetchPrice]);
+
+  useEffect(() => {
+    if (!autoRefresh) return;
+
+    const interval = setInterval(fetchPrice, refreshInterval);
+    return () => clearInterval(interval);
+  }, [autoRefresh, refreshInterval, fetchPrice]);
+
+  return {
+    price,
+    isLoading,
+    error,
+    refetch: fetchPrice,
+  };
+}
+
+// Hook for multiple token prices
+interface UseTokenPricesReturn {
+  prices: Record<string, TokenPrice>;
+  isLoading: boolean;
+  error: string | null;
+  refetch: () => Promise<void>;
+}
+
+export function useTokenPrices(
+  symbols: string[],
+  options: UseTokenPriceOptions = {}
+): UseTokenPricesReturn {
+  const { autoRefresh = false, refreshInterval = 30000, engineUrl, clientId } = options;
+
+  const [prices, setPrices] = useState<Record<string, TokenPrice>>({});
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const engineRef = useRef(createOneEngineClient({
+    baseUrl: engineUrl,
+    clientId: clientId,
+  }));
+
+  const fetchPrices = useCallback(async () => {
+    if (symbols.length === 0) return;
+
+    setIsLoading(true);
+    setError(null);
+
+    try {
+      const result = await engineRef.current.getTokenPrices(symbols);
+      if (result.success && result.data) {
+        const priceMap: Record<string, TokenPrice> = {};
+        for (const sym of symbols) {
+          if (result.data[sym]) {
+            priceMap[sym] = {
+              symbol: sym,
+              price: result.data[sym].price,
+              change24h: result.data[sym].change24h,
+              changePercent24h: result.data[sym].change24h,
+              marketCap: result.data[sym].marketCap,
+              volume24h: 0,
+              updatedAt: new Date().toISOString(),
+            };
+          }
+        }
+        setPrices(priceMap);
+      } else {
+        setError(result.error?.message || 'Failed to fetch prices');
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to fetch prices');
+    } finally {
+      setIsLoading(false);
+    }
+  }, [symbols]);
+
+  useEffect(() => {
+    fetchPrices();
+  }, [fetchPrices]);
+
+  useEffect(() => {
+    if (!autoRefresh) return;
+
+    const interval = setInterval(fetchPrices, refreshInterval);
+    return () => clearInterval(interval);
+  }, [autoRefresh, refreshInterval, fetchPrices]);
+
+  return {
+    prices,
+    isLoading,
+    error,
+    refetch: fetchPrices,
+  };
+}

package/src/hooks/useWalletBalance.ts

@@ -0,0 +1,98 @@
+import { useState, useEffect, useCallback, useRef } from 'react';
+import { createOneEngineClient, type EngineWalletBalance } from '../services/engine';
+import type { Token } from '../types';
+
+interface UseWalletBalanceOptions {
+  chains?: number[];
+  autoRefresh?: boolean;
+  refreshInterval?: number; // in milliseconds
+  engineUrl?: string;
+  clientId?: string;
+}
+
+interface UseWalletBalanceReturn {
+  balance: EngineWalletBalance | null;
+  tokens: Token[];
+  totalUsd: number;
+  change24h: number;
+  changePercent24h: number;
+  isLoading: boolean;
+  error: string | null;
+  refetch: () => Promise<void>;
+}
+
+/**
+ * Hook for fetching wallet balance via ONE Engine
+ *
+ * Note: If using OneProvider, prefer useOneWallet() instead for better integration.
+ * This hook is for standalone usage outside of OneProvider.
+ */
+export function useWalletBalance(
+  walletAddress: string | null,
+  options: UseWalletBalanceOptions = {}
+): UseWalletBalanceReturn {
+  const {
+    chains,
+    autoRefresh = false,
+    refreshInterval = 60000, // 1 minute
+    engineUrl,
+    clientId,
+  } = options;
+
+  const [balance, setBalance] = useState<EngineWalletBalance | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  // Create engine client once
+  const engineRef = useRef(createOneEngineClient({
+    baseUrl: engineUrl,
+    clientId: clientId,
+  }));
+
+  const fetchBalance = useCallback(async () => {
+    if (!walletAddress) {
+      setBalance(null);
+      return;
+    }
+
+    setIsLoading(true);
+    setError(null);
+
+    try {
+      const result = await engineRef.current.getWalletBalance(walletAddress, chains);
+      if (result.success && result.data) {
+        setBalance(result.data);
+      } else {
+        setError(result.error?.message || 'Failed to fetch balance');
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to fetch balance');
+    } finally {
+      setIsLoading(false);
+    }
+  }, [walletAddress, chains]);
+
+  // Initial fetch
+  useEffect(() => {
+    fetchBalance();
+  }, [fetchBalance]);
+
+  // Auto-refresh
+  useEffect(() => {
+    if (!autoRefresh || !walletAddress) return;
+
+    const interval = setInterval(fetchBalance, refreshInterval);
+    return () => clearInterval(interval);
+  }, [autoRefresh, refreshInterval, fetchBalance, walletAddress]);
+
+  return {
+    balance,
+    tokens: balance?.tokens || [],
+    totalUsd: balance?.totalUsd || 0,
+    change24h: balance?.change24h || 0,
+    changePercent24h: balance?.changePercent24h || 0,
+    isLoading,
+    error,
+    refetch: fetchBalance,
+  };
+}