// Main Diamond Proxy
DIAMOND_ADDRESS = "0xEfE193A5862152e229aFbDB9F4F8C89129FCd43D";

// Database & Authentication
- PostgreSQL database with Row Level Security
- Real-time subscriptions for live updates
- Built-in authentication with social providers
- File storage for documents and images

// Decentralized Storage
- Document storage for asset verification
- Metadata storage for NFTs
- Gateway for accessing stored files
- API for programmatic uploads

// Market Data
- Real-time cryptocurrency prices
- Historical price data
- Market cap and volume information
- Rate limiting and caching implemented

// SSR-safe wallet provider loading
const getWalletProvider = async () => {
  if (typeof window === "undefined") return null;
  const { walletProvider } = await import("./wallet-provider");
  return walletProvider;
};

// Fixed params handling
export default function AssetPage({ params }: { params: { id: string } }) {
  const { id } = params; // Direct destructuring instead of use(params)
}

// Development configuration with public RPCs
NEXT_PUBLIC_ETHEREUM_RPC_URL=https://cloudflare-eth.com

class PriceService {
  private requestQueue = [];
  private cache = new Map();
  private readonly REQUEST_DELAY = 1000; // 1 second between requests
}

// App Router File-based Routing
src/app/
├── (auth)/                 # Route groups for authentication
│   ├── sign-in/           # Login page
│   ├── sign-up/           # Registration page
│   └── layout.tsx         # Auth layout
├── admin/                 # Admin dashboard routes
│   ├── page.tsx          # Admin overview
│   ├── assets/           # Asset management
│   ├── users/            # User management
│   └── settings/         # System settings
├── api/                  # API routes
│   ├── admin/            # Admin endpoints
│   ├── blockchain/       # Blockchain endpoints
│   └── wallet-connections/ # Wallet endpoints
├── dashboard/            # Main application routes
│   ├── page.tsx         # Dashboard home
│   ├── assets/          # Asset management
│   │   ├── [id]/        # Dynamic asset routes
│   │   │   ├── page.tsx # Asset detail
│   │   │   └── edit/    # Asset editing
│   │   └── new/         # Asset creation
│   ├── loans/           # Loan management
│   ├── portfolio/       # Portfolio analytics
│   └── settings/        # User settings
├── layout.tsx           # Root layout
├── page.tsx            # Landing page
├── loading.tsx         # Global loading UI
├── error.tsx           # Global error UI
└── not-found.tsx       # 404 page

// Component Hierarchy
src/components/
├── ui/                    # Base UI components (shadcn/ui)
│   ├── button.tsx        # Reusable button component
│   ├── card.tsx          # Card container
│   ├── input.tsx         # Form inputs
│   ├── dialog.tsx        # Modal dialogs
│   └── ...               # Other base components
├── dashboard/            # Dashboard-specific components
│   ├── EnhancedDashboard.tsx    # Main dashboard
│   ├── PortfolioChart.tsx       # Portfolio visualization
│   ├── AssetCard.tsx            # Asset display
│   ├── TransactionHistory.tsx   # Transaction list
│   └── MarketInsights.tsx       # Market data
├── admin/                # Admin components
│   ├── AdminDashboard.tsx       # Admin interface
│   ├── UserManagement.tsx       # User admin
│   └── AssetApproval.tsx        # Asset verification
└── common/               # Shared components
    ├── Header.tsx        # Site header
    ├── Footer.tsx        # Site footer
    └── LoadingSpinner.tsx # Loading states

// Custom Hooks for State Management
src/hooks/
├── useBlockchainData.ts     # Blockchain state management
├── usePortfolioDashboard.ts # Portfolio state
├── useAdmin.ts              # Admin functionality
├── useAssets.ts             # Asset management
├── useLoans.ts              # Loan management
└── useAuth.ts               # Authentication state

// Example: useBlockchainData Hook
export const useBlockchainData = () => {
  const [portfolioData, setPortfolioData] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  const fetchPortfolioData = useCallback(async (walletAddress: string) => {
    try {
      setLoading(true);
      const service = await getBlockchainDataService();
      const data = await service.getPortfolioData(walletAddress);
      setPortfolioData(data);
    } catch (err) {
      setError(err);
    } finally {
      setLoading(false);
    }
  }, []);

  return { portfolioData, loading, error, fetchPortfolioData };
};

// Database Client Configuration
// supabase/client.ts (Client-side)
import { createClientComponentClient } from "@supabase/auth-helpers-nextjs";

export const createClient = () => {
  return createClientComponentClient({
    supabaseUrl: process.env.NEXT_PUBLIC_SUPABASE_URL!,
    supabaseKey: process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
  });
};

// supabase/server.ts (Server-side)
import { createServerComponentClient } from "@supabase/auth-helpers-nextjs";
import { cookies } from "next/headers";

export const createServerClient = () => {
  return createServerComponentClient({
    cookies,
    supabaseUrl: process.env.NEXT_PUBLIC_SUPABASE_URL!,
    supabaseKey: process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
  });
};

// API Route Examples
// src/app/api/blockchain/portfolio/route.ts
export async function GET(request: Request) {
  try {
    const { searchParams } = new URL(request.url);
    const walletAddress = searchParams.get("wallet");

    if (!walletAddress) {
      return NextResponse.json(
        { error: "Wallet address required" },
        { status: 400 }
      );
    }

    const service = await getBlockchainDataService();
    const portfolioData = await service.getPortfolioData(walletAddress);

    return NextResponse.json(portfolioData);
  } catch (error) {
    console.error("Portfolio API error:", error);
    return NextResponse.json(
      { error: "Failed to fetch portfolio data" },
      { status: 500 }
    );
  }
}

// src/app/api/admin/assets/route.ts
export async function GET(request: Request) {
  const supabase = createServerClient();

  // Check admin permissions
  const {
    data: { user },
  } = await supabase.auth.getUser();
  if (!user || !isAdmin(user.email)) {
    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
  }

  // Fetch assets for admin review
  const { data: assets, error } = await supabase
    .from("assets")
    .select("*")
    .eq("verification_status", "pending")
    .order("created_at", { ascending: false });

  if (error) {
    return NextResponse.json({ error: error.message }, { status: 500 });
  }

  return NextResponse.json(assets);
}

// middleware.ts
import { createMiddlewareClient } from "@supabase/auth-helpers-nextjs";
import { NextResponse } from "next/server";
import type { NextRequest } from "next/server";

export async function middleware(req: NextRequest) {
  const res = NextResponse.next();
  const supabase = createMiddlewareClient({ req, res });

  // Refresh session if expired
  const {
    data: { session },
  } = await supabase.auth.getSession();

  // Protected routes
  const protectedPaths = ["/dashboard", "/admin"];
  const isProtectedPath = protectedPaths.some((path) =>
    req.nextUrl.pathname.startsWith(path)
  );

  if (isProtectedPath && !session) {
    return NextResponse.redirect(new URL("/sign-in", req.url));
  }

  // Admin-only routes
  if (req.nextUrl.pathname.startsWith("/admin")) {
    const user = session?.user;
    if (!user || !isAdmin(user.email)) {
      return NextResponse.redirect(new URL("/dashboard", req.url));
    }
  }

  return res;
}

export const config = {
  matcher: [
    "/((?!_next/static|_next/image|favicon.ico|.*\\.(?:svg|png|jpg|jpeg|gif|webp)$).*)",
  ],
};

// src/lib/web3/blockchain-config.ts
export const BLOCKCHAIN_NETWORKS = {
  ethereum: {
    chainId: 1,
    name: "Ethereum Mainnet",
    rpcUrl: process.env.NEXT_PUBLIC_ETHEREUM_RPC_URL,
    blockExplorer: "https://etherscan.io",
    nativeCurrency: {
      name: "Ethereum",
      symbol: "ETH",
      decimals: 18,
    },
  },
  avalanche: {
        chainId: 43113,
        name: "Avalanche Fuji",
        symbol: "AVAX",
        rpcUrl: process.env.NEXT_PUBLIC_AVALANCHE_RPC_URL ||
            "https://avalanche-fuji-c-chain-rpc.publicnode.com",
        blockExplorer: "https://testnet.snowtrace.io/",
        isTestnet: true,
        nativeCurrency: {
            name: "Avalanche",
            symbol: "AVAX",
            decimals: 18,
        },  
    },
  sepolia: {
        chainId: 11155111,
        name: "Ethereum Sepolia",
        symbol: "SepoliaETH",
        rpcUrl: process.env.NEXT_PUBLIC_SEPOLIA_RPC_URL ||
            "https://eth-sepolia.g.alchemy.com/v2/demo",
        blockExplorer: "https://sepolia.etherscan.io",
        isTestnet: true,
        nativeCurrency: {
            name: "Ethereum",
            symbol: "ETH",
            decimals: 18,
        },
   }
  arbitrum: {
    chainId: 42161,
    name: "Arbitrum One",
    rpcUrl: process.env.NEXT_PUBLIC_ARBITRUM_RPC_URL,
    blockExplorer: "https://arbiscan.io",
    nativeCurrency: {
      name: "Ethereum",
      symbol: "ETH",
      decimals: 18,
    },
  },
  optimism: {
        chainId: 11155420,
        name: "Optimism Sepolia",
        symbol: "OP",
        rpcUrl: process.env.NEXT_PUBLIC_OPTIMISM_RPC_URL ||
            "https://endpoints.omniatech.io/v1/op/sepolia/public",
        blockExplorer: "https://sepolia-optimism.etherscan.io/",
        isTestnet: true,
        nativeCurrency: {
            name: "Ethereum",
            symbol: "ETH",
            decimals: 18,
        },
    },
    base: {
        chainId: 84532,
        name: "Base Sepolia",
        symbol: "BASE",
        rpcUrl: process.env.NEXT_PUBLIC_BASE_RPC_URL ||
            "https://base-sepolia.drpc.org",
        blockExplorer: "https://sepolia.basescan.org/",
        isTestnet: true,
        nativeCurrency: {
            name: "Ethereum",
            symbol: "ETH",
            decimals: 18,
        },
    },
    unichain: {
        chainId: 1301,
        name: "Unichain Sepolia",
        symbol: "UNI",
        rpcUrl: process.env.NEXT_PUBLIC_UNICHAIN_RPC_URL ||
            "https://unichain-sepolia-rpc.publicnode.com",
        blockExplorer: "https://unichain-sepolia.blockscout.com/",
        isTestnet: true,
        nativeCurrency: {
            name: "Ethereum",
            symbol: "ETH",
            decimals: 18,
        },
    },
};

export const TESTNET_NETWORKS = {
  sepolia: {
    chainId: 11155111,
    name: "Sepolia Testnet",
    rpcUrl: process.env.NEXT_PUBLIC_SEPOLIA_RPC_URL,
    blockExplorer: "https://sepolia.etherscan.io",
    contracts: {
      diamond: process.env.NEXT_PUBLIC_SEPOLIA_DIAMOND_ADDRESS,
      authUser: process.env.NEXT_PUBLIC_SEPOLIA_AUTH_USER_ADDRESS,
      crosschain: process.env.NEXT_PUBLIC_SEPOLIA_CROSSCHAIN_ADDRESS,
    },
  },
};

// src/lib/web3/wallet-provider.ts
class WalletProvider {
  private provider: any = null;
  private signer: any = null;
  private address: string | null = null;

  // SSR-safe initialization
  async initialize() {
    if (typeof window === "undefined") {
      throw new Error("Wallet provider can only be initialized on client side");
    }

    try {
      // Dynamic import to avoid SSR issues
      const { ethers } = await import("ethers");

      if (window.ethereum) {
        this.provider = new ethers.BrowserProvider(window.ethereum);
        await this.provider.send("eth_requestAccounts", []);
        this.signer = await this.provider.getSigner();
        this.address = await this.signer.getAddress();
      } else {
        throw new Error("No Web3 wallet detected");
      }
    } catch (error) {
      console.error("Failed to initialize wallet provider:", error);
      throw error;
    }
  }

  async switchNetwork(chainId: number) {
    if (!this.provider) throw new Error("Wallet not connected");

    try {
      await window.ethereum.request({
        method: "wallet_switchEthereumChain",
        params: [{ chainId: `0x${chainId.toString(16)}` }],
      });
    } catch (switchError: any) {
      // Network not added to wallet
      if (switchError.code === 4902) {
        const network = Object.values(BLOCKCHAIN_NETWORKS).find(
          (n) => n.chainId === chainId
        );
        if (network) {
          await this.addNetwork(network);
        }
      }
      throw switchError;
    }
  }

  async getBalance(tokenAddress?: string): Promise<string> {
    if (!this.provider || !this.address) return "0";

    try {
      if (tokenAddress) {
        // ERC-20 token balance
        const { ethers } = await import("ethers");
        const tokenContract = new ethers.Contract(
          tokenAddress,
          ["function balanceOf(address) view returns (uint256)"],
          this.provider
        );
        const balance = await tokenContract.balanceOf(this.address);
        return ethers.formatEther(balance);
      } else {
        // Native token balance
        const balance = await this.provider.getBalance(this.address);
        const { ethers } = await import("ethers");
        return ethers.formatEther(balance);
      }
    } catch (error) {
      console.error("Failed to get balance:", error);
      return "0";
    }
  }
}

// Singleton instance with SSR safety
let walletProviderInstance: WalletProvider | null = null;

export const getWalletProvider = async (): Promise<WalletProvider> => {
  if (typeof window === "undefined") {
    throw new Error("Wallet provider not available on server side");
  }

  if (!walletProviderInstance) {
    walletProviderInstance = new WalletProvider();
    await walletProviderInstance.initialize();
  }

  return walletProviderInstance;
};

// src/lib/web3/blockchain-data-service.ts
class BlockchainDataService {
  private cache = new Map<string, { data: any; timestamp: number }>();
  private readonly CACHE_DURATION = 5 * 60 * 1000; // 5 minutes

  async getPortfolioData(walletAddress: string) {
    const cacheKey = `portfolio_${walletAddress}`;
    const cached = this.cache.get(cacheKey);

    if (cached && Date.now() - cached.timestamp < this.CACHE_DURATION) {
      return cached.data;
    }

    try {
      // Parallel data fetching from multiple sources
      const [balances, transactions, prices] = await Promise.all([
        this.getMultiChainBalances(walletAddress),
        this.getTransactionHistory(walletAddress),
        this.getCurrentPrices(),
      ]);

      const portfolioData = {
        totalValue: this.calculateTotalValue(balances, prices),
        balances,
        transactions,
        prices,
        lastUpdated: new Date().toISOString(),
      };

      // Cache the result
      this.cache.set(cacheKey, {
        data: portfolioData,
        timestamp: Date.now(),
      });

      return portfolioData;
    } catch (error) {
      console.error("Failed to fetch portfolio data:", error);
      // Return mock data for development
      return this.generateMockPortfolioData(walletAddress);
    }
  }

  private async getMultiChainBalances(walletAddress: string) {
    const networks = Object.keys(BLOCKCHAIN_NETWORKS);
    const balancePromises = networks.map(async (network) => {
      try {
        const provider = await this.getProvider(network);
        const balance = await provider.getBalance(walletAddress);
        const { ethers } = await import("ethers");

        return {
          network,
          balance: ethers.formatEther(balance),
          symbol: BLOCKCHAIN_NETWORKS[network].nativeCurrency.symbol,
        };
      } catch (error) {
        console.error(`Failed to get balance for ${network}:`, error);
        return {
          network,
          balance: "0",
          symbol: BLOCKCHAIN_NETWORKS[network].nativeCurrency.symbol,
        };
      }
    });

    return Promise.all(balancePromises);
  }

  private generateMockPortfolioData(walletAddress: string) {
    return {
      totalValue: 125000.5,
      balances: [
        { network: "ethereum", balance: "2.5", symbol: "ETH" },
        { network: "arbitrum", balance: "1.2", symbol: "ETH" },
       //other chains..
      ],
      transactions: this.generateMockTransactions(),
      prices: {
        ethereum: 2500.0,
        polygon: 0.85,
        bitcoin: 45000.0,
      },
      lastUpdated: new Date().toISOString(),
    };
  }

  private generateMockTransactions() {
    const types = ["mint", "transfer", "loan", "payment"];
    const networks = ["ethereum", "polygon", "arbitrum"];

    return Array.from({ length: 10 }, (_, i) => ({
      id: `tx_${i + 1}`,
      hash: `0x${Math.random().toString(16).substr(2, 64)}`,
      type: types[Math.floor(Math.random() * types.length)],
      amount: (Math.random() * 1000).toFixed(2),
      network: networks[Math.floor(Math.random() * networks.length)],
      timestamp: new Date(
        Date.now() - Math.random() * 30 * 24 * 60 * 60 * 1000
      ).toISOString(),
      status: "confirmed",
    }));
  }
}

// Singleton instance
let blockchainDataServiceInstance: BlockchainDataService | null = null;

export const getBlockchainDataService =
  async (): Promise<BlockchainDataService> => {
    if (!blockchainDataServiceInstance) {
      blockchainDataServiceInstance = new BlockchainDataService();
    }
    return blockchainDataServiceInstance;
  };

// src/lib/web3/price-service.ts
class PriceService {
  private requestQueue: Array<() => Promise<any>> = [];
  private isProcessing = false;
  private cache = new Map<string, { data: any; timestamp: number }>();
  private readonly CACHE_DURATION = 5 * 60 * 1000; // 5 minutes
  private readonly REQUEST_DELAY = 1000; // 1 second between requests

  async getCurrentPrices(
    symbols: string[] = ["ethereum", "polygon-ecosystem-token", "bitcoin"]
  ) {
    const cacheKey = symbols.sort().join(",");
    const cached = this.cache.get(cacheKey);

    if (cached && Date.now() - cached.timestamp < this.CACHE_DURATION) {
      return cached.data;
    }

    return this.queueRequest(async () => {
      try {
        const response = await fetch(
          `https://api.coingecko.com/api/v3/simple/price?ids=${symbols.join(",")}&vs_currencies=usd`,
          {
            headers: {
              "X-CG-Demo-API-Key": process.env.COINGECKO_API_KEY || "",
            },
          }
        );

        if (!response.ok) {
          throw new Error(`HTTP error! status: ${response.status}`);
        }

        const data = await response.json();

        // Cache the result
        this.cache.set(cacheKey, {
          data,
          timestamp: Date.now(),
        });

        return data;
      } catch (error) {
        console.error("Failed to fetch prices:", error);
        // Return mock prices for development
        return {
          ethereum: { usd: 2500.0 },
          "polygon-ecosystem-token": { usd: 0.85 },
          bitcoin: { usd: 45000.0 },
        };
      }
    });
  }

  private async queueRequest<T>(requestFn: () => Promise<T>): Promise<T> {
    return new Promise((resolve, reject) => {
      this.requestQueue.push(async () => {
        try {
          const result = await requestFn();
          resolve(result);
        } catch (error) {
          reject(error);
        }
      });

      this.processQueue();
    });
  }

  private async processQueue() {
    if (this.isProcessing || this.requestQueue.length === 0) {
      return;
    }

    this.isProcessing = true;

    while (this.requestQueue.length > 0) {
      const request = this.requestQueue.shift();
      if (request) {
        await request();
        // Wait between requests to respect rate limits
        await new Promise((resolve) => setTimeout(resolve, this.REQUEST_DELAY));
      }
    }

    this.isProcessing = false;
  }
}

// Singleton instance
let priceServiceInstance: PriceService | null = null;

export const getPriceService = (): PriceService => {
  if (!priceServiceInstance) {
    priceServiceInstance = new PriceService();
  }
  return priceServiceInstance;
};

// Row Level Security (RLS) Policies
-- Users can only access their own assets
CREATE POLICY "Users can view own assets" ON assets
  FOR SELECT USING (auth.uid() = user_id);

-- Admin users can view all assets
CREATE POLICY "Admins can view all assets" ON assets
  FOR SELECT USING (
    auth.uid() IN (
      SELECT id FROM auth.users
      WHERE email = ANY(string_to_array(
        current_setting('app.admin_emails', true), ','
      ))
    )
  );

-- Users can only update their own assets
CREATE POLICY "Users can update own assets" ON assets
  FOR UPDATE USING (auth.uid() = user_id);

// API Route Protection
export async function GET(request: Request) {
  const supabase = createServerClient();

  // Verify authentication
  const {
    data: { user },
    error,
  } = await supabase.auth.getUser();
  if (error || !user) {
    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
  }

  // Rate limiting (implement with Upstash Redis or similar)
  const rateLimitKey = `rate_limit_${user.id}`;
  const requests = await redis.incr(rateLimitKey);
  if (requests === 1) {
    await redis.expire(rateLimitKey, 60); // 1 minute window
  }
  if (requests > 100) {
    // 100 requests per minute
    return NextResponse.json({ error: "Rate limit exceeded" }, { status: 429 });
  }

  // Continue with API logic...
}

// Code Splitting and Lazy Loading
const AdminDashboard = lazy(() => import('@/components/admin/AdminDashboard'));
const PortfolioChart = lazy(() => import('@/components/dashboard/PortfolioChart'));

// Memoization for expensive calculations
const MemoizedPortfolioChart = memo(({ data }: { data: PortfolioData }) => {
  const chartData = useMemo(() => {
    return processPortfolioData(data);
  }, [data]);

  return <PortfolioChart data={chartData} />;
});

// Optimized re-renders
const AssetCard = memo(({ asset }: { asset: Asset }) => {
  const handleClick = useCallback(() => {
    router.push(`/dashboard/assets/${asset.id}`);
  }, [asset.id, router]);

  return (
    <Card onClick={handleClick}>
      {/* Asset content */}
    </Card>
  );
});

// Database Query Optimization
const getAssetsWithPagination = async (
  userId: string,
  page: number = 1,
  limit: number = 10
) => {
  const offset = (page - 1) * limit;

  const { data, error } = await supabase
    .from("assets")
    .select(
      `
      id,
      name,
      current_value,
      asset_type,
      verification_status,
      created_at
    `
    )
    .eq("user_id", userId)
    .order("created_at", { ascending: false })
    .range(offset, offset + limit - 1);

  return { data, error };
};

// Caching Strategy
class CacheManager {
  private cache = new Map();
  private readonly DEFAULT_TTL = 5 * 60 * 1000; // 5 minutes

  set(key: string, value: any, ttl: number = this.DEFAULT_TTL) {
    this.cache.set(key, {
      value,
      expires: Date.now() + ttl,
    });
  }

  get(key: string) {
    const item = this.cache.get(key);
    if (!item) return null;

    if (Date.now() > item.expires) {
      this.cache.delete(key);
      return null;
    }

    return item.value;
  }
}

// Batch RPC Calls
class OptimizedBlockchainService {
  async getMultipleBalances(addresses: string[], tokenAddresses: string[]) {
    const calls = addresses.flatMap((address) =>
      tokenAddresses.map((token) => ({
        target: token,
        callData: encodeFunctionData({
          abi: ERC20_ABI,
          functionName: "balanceOf",
          args: [address],
        }),
      }))
    );

    // Use multicall contract to batch requests
    const results = await multicallContract.aggregate(calls);
    return this.parseMulticallResults(results, addresses, tokenAddresses);
  }

  // Connection pooling for RPC providers
  private providers = new Map<string, ethers.JsonRpcProvider>();

  getProvider(network: string): ethers.JsonRpcProvider {
    if (!this.providers.has(network)) {
      const config = BLOCKCHAIN_NETWORKS[network];
      const provider = new ethers.JsonRpcProvider(config.rpcUrl, {
        name: config.name,
        chainId: config.chainId,
      });
      this.providers.set(network, provider);
    }
    return this.providers.get(network)!;
  }
}

// Before (causing SSR errors)
import { walletProvider } from "./wallet-provider";

// After (SSR-safe)
const getWalletProvider = async () => {
  if (typeof window === "undefined") return null;
  const { walletProvider } = await import("./wallet-provider");
  return walletProvider;
};

// Before (causing Suspense error)
import { use } from "react";
export default function AssetPage({
  params,
}: {
  params: Promise<{ id: string }>;
}) {
  const { id } = use(params);
}

// After (fixed)
export default function AssetPage({ params }: { params: { id: string } }) {
  const { id } = params;
}

// Removed problematic external script
// src/app/layout.tsx - removed tempolabs.ai script tag

// Updated to use public RPC endpoints
NEXT_PUBLIC_ARBITRUM_RPC_URL=https://endpoints.omniatech.io/v1/arbitrum/sepolia/public
NEXT_PUBLIC_OPTIMISM_RPC_URL=https://endpoints.omniatech.io/v1/op/sepolia/public
NEXT_PUBLIC_AVALANCHE_RPC_URL=https://avalanche-fuji-c-chain-rpc.publicnode.com
NEXT_PUBLIC_SEPOLIA_RPC_URL=https://rpc.sepolia.org
NEXT_PUBLIC_BASE_RPC_URL=https://base-sepolia.drpc.org
NEXT_PUBLIC_UNICHAIN_RPC_URL=https://unichain-sepolia-rpc.publicnode.com

// Implemented request queuing and caching
class PriceService {
  private requestQueue: Array<() => Promise<any>> = [];
  private cache = new Map();
  private readonly REQUEST_DELAY = 1000; // 1 second between requests

  async queueRequest(requestFn: () => Promise<any>) {
    // Rate limiting implementation
  }
}

// Replaced with mock transaction generation
private generateMockTransactions() {
  return Array.from({ length: 10 }, (_, i) => ({
    id: `tx_${i + 1}`,
    hash: `0x${Math.random().toString(16).substr(2, 64)}`,
    // ... mock transaction data
  }));
}

// Added proper type checking and fallbacks
const formatBalance = (balance: any): string => {
  if (typeof balance === "number") {
    return balance.toFixed(2);
  }
  if (typeof balance === "string" && !isNaN(Number(balance))) {
    return Number(balance).toFixed(2);
  }
  return "0.00";
};