[V0_FILE]yaml:file=".github/workflows/deploy.yml" name: Deploy to GitHub Pages on: push: branches: - main workflow_dispatch: permissions: contents: read pages: write id-token: write concurrency: group: "pages" cancel-in-progress: true jobs: build: runs-on: ubuntu-latest steps: - name: Checkout uses: actions/checkout@v4 - name: Set up PNPM uses: pnpm/action-setup@v4 with: version: 9 - name: Set up Node uses: actions/setup-node@v4 with: node-version: 20 cache: pnpm - name: Install dependencies run: pnpm install --frozen-lockfile - name: Build run: pnpm run build - name: Upload artifact uses: actions/upload-pages-artifact@v3 with: path: ./out deploy: environment: name: github-pages url: ${{ steps.deployment.outputs.page_url }} runs-on: ubuntu-latest needs: build steps: - name: Deploy to GitHub Pages id: deployment uses: actions/deploy-pages@v4 [V0_FILE]plaintext:file=".gitignore" # See https://help.github.com/articles/ignoring-files/ for more about ignoring files. # dependencies /node_modules # next.js /.next/ /out/ # production /build # debug npm-debug.log* yarn-debug.log* yarn-error.log* .pnpm-debug.log* # env files .env* # vercel .vercel # typescript *.tsbuildinfo next-env.d.ts [V0_FILE]markdown:file="ADMIN_SETUP.md" # Admin Access Control Setup ## Overview The admin panel is now restricted to authorized wallet addresses only. Users who are not authorized will see an "Access Denied" message. ## Setup Instructions ### 1. Add Admin Wallet Address(es) to Environment Variables Add your admin wallet address(es) to the project environment variables: **Variable Name:** `NEXT_PUBLIC_ADMIN_ADDRESSES` **Format:** Comma-separated list of wallet addresses (case-insensitive) **Example:** \`\`\` NEXT_PUBLIC_ADMIN_ADDRESSES=0x1234567890abcdef1234567890abcdef12345678,0xabcdefabcdefabcdefabcdefabcdefabcdefabcd \`\`\` ### 2. How to Add Environment Variables **Option A: Via Vercel Dashboard** 1. Go to your project settings in Vercel 2. Navigate to "Environment Variables" 3. Add `NEXT_PUBLIC_ADMIN_ADDRESSES` with your wallet address(es) 4. Redeploy your application **Option B: Via v0 Chat Sidebar** 1. Click on "Vars" in the left sidebar 2. Add the environment variable 3. The changes will be automatically applied ### 3. Getting Your Wallet Address To find your wallet address: 1. Connect your wallet to the meme launchpad 2. Click the hamburger menu in the top right 3. Your wallet address will be displayed in the format: `0x1234...5678` 4. Copy the full address from your wallet extension (e.g., MetaMask) ## Features - **Header Menu**: Admin link only appears for authorized users - **Admin Page**: Shows access denied message for unauthorized users - **Multiple Admins**: Supports multiple admin addresses (comma-separated) - **Case Insensitive**: Address comparison is case-insensitive ## Security Notes - The `NEXT_PUBLIC_` prefix makes this variable accessible on the client-side - Admin addresses are checked in real-time when the wallet connects - Direct URL access to `/admin` is blocked for non-admin users ## Testing 1. Add your wallet address to `NEXT_PUBLIC_ADMIN_ADDRESSES` 2. Connect your wallet 3. Check if the Admin option appears in the hamburger menu 4. Verify you can access the admin panel at `/admin` 5. Test with a different wallet address to confirm access is denied [V0_FILE]markdown:file="CONTRACT_SETUP_INSTRUCTIONS.md" # How to Integrate Your New Contract Follow these steps to connect your new meme launchpad contract: ## Step 1: Clear Existing Token Data Run the SQL script to remove all existing tokens from the database: 1. Go to your Supabase dashboard 2. Navigate to the SQL Editor 3. Run the script: `scripts/012_clear_all_tokens.sql` This will delete all: - Meme tokens - Starred tokens - Token holders - User points **Note:** User profiles are preserved by default. If you want to clear those too, uncomment the last line in the script. ## Step 2: Update Contract Address In `lib/contract-config.ts`: \`\`\`typescript export const CONTRACT_CONFIG = { address: "0xYourNewContractAddressHere", // Replace this chainId: 1155, // Update if different network network: { name: "Intuition Mainnet", rpcUrl: "https://rpc.intuition.systems", currency: "TRUST", blockExplorer: "https://intuition.calderaexplorer.xyz/", }, } \`\`\` ## Step 3: Replace Contract ABI In `lib/contract-abi.json`: 1. Copy your contract's complete ABI from: - Your contract verification on the block explorer, OR - Your contract's build artifacts (usually in `artifacts/` or `out/` folder) 2. Replace the entire contents of `lib/contract-abi.json` with your new ABI **Required Functions:** Your contract should have at minimum: - `createToken(name, symbol, metadata)` - To create new meme tokens - `buyTokens(tokenAddress, minTokensOut)` - To buy tokens (payable) - `sellTokens(tokenAddress, tokenAmount)` - To sell tokens - `getTokenInfo(tokenAddress)` - To fetch token details - `getAllTokens()` - To list all tokens - `getCurrentPrice(tokenAddress)` - To get current token price ## Step 4: Verify Integration After updating the contract address and ABI: 1. Test token creation 2. Test buying tokens 3. Test selling tokens 4. Verify prices display correctly 5. Check that token filtering works ## Troubleshooting If you encounter errors: 1. **"Invalid address" errors**: Double-check your contract address format (should start with 0x) 2. **"Function not found" errors**: Verify your ABI has all required functions 3. **Gas estimation failures**: Ensure your contract is deployed and verified on the network 4. **Network errors**: Check that the RPC URL and chain ID match your deployment network ## Need Help? Make sure your new contract follows the same interface as the original: - Uses the bonding curve formula for pricing - Tracks user volumes for the points system - Emits events for token creation, buying, and selling [V0_FILE]markdown:file="LEADERBOARD_SETUP.md" # Leaderboard Daily Updates Setup The leaderboard system is designed to update daily with cached data for performance. ## How It Works 1. **Automatic Daily Updates**: The leaderboard automatically checks if cached data is older than 24 hours and triggers a background refresh 2. **Cached Data**: Leaderboard data is stored in the `leaderboard_cache` table for fast loading 3. **Manual Refresh**: Admins can manually trigger a refresh using the "Refresh Now" button ## Setup Instructions ### 1. Run the Database Migration Execute the SQL script to create the cache table: \`\`\`bash # The script is located at: scripts/014_create_leaderboard_cache.sql \`\`\` ### 2. Set Up Automatic Daily Refresh (Optional but Recommended) For automatic daily updates, set up a cron job that calls the refresh API: **Option A: Vercel Cron Jobs** Add to your `vercel.json`: \`\`\`json { "crons": [{ "path": "/api/leaderboard/refresh", "schedule": "0 0 * * *" }] } \`\`\` **Option B: External Cron Service** Use a service like cron-job.org or EasyCron to call: \`\`\` https://your-domain.com/api/leaderboard/refresh \`\`\` Schedule: Daily at midnight (0 0 * * *) ### 3. Initial Cache Population After setup, manually trigger the first refresh: - As an admin, visit the leaderboard page and click "Refresh Now" - Or call the API directly: `POST https://your-domain.com/api/leaderboard/refresh` ## Features - **Top Traders**: Displays top 25 users by trading volume (fetched from blockchain) - **Most Active**: Shows top 25 users by accumulated points (trading + comments) - **Last Updated Timestamp**: Shows when the data was last refreshed - **Admin Controls**: Admins can manually refresh the leaderboard anytime - **Automatic Refresh**: Stale data (>24 hours) triggers background refresh automatically ## API Endpoints ### POST /api/leaderboard/refresh Refreshes the leaderboard cache with fresh data from the blockchain and database. **Response:** \`\`\`json { "success": true, "message": "Leaderboard refreshed successfully", "timestamp": "2024-01-01T00:00:00.000Z", "data": { "topTraders": 25, "mostActive": 25 } } \`\`\` ### GET /api/leaderboard/refresh Same as POST - useful for cron jobs that only support GET requests. ## Performance - Cached data loads instantly (no blockchain calls) - Background refresh happens asynchronously - Users always see data, even during refresh - Blockchain queries only happen during refresh (not on every page load) [V0_FILE]markdown:file="README.md" # TribeOrientedAppmain *Automatically synced with your [v0.app](https://v0.app) deployments* [![Deployed on Vercel](https://img.shields.io/badge/Deployed%20on-Vercel-black?style=for-the-badge&logo=vercel)](https://vercel.com/jennasuddsca-8812s-projects/v0-tribe-oriented-appmain) [![Built with v0](https://img.shields.io/badge/Built%20with-v0.app-black?style=for-the-badge)](https://v0.app/chat/LKSfRKWUqiJ) ## Overview This repository will stay in sync with your deployed chats on [v0.app](https://v0.app). Any changes you make to your deployed app will be automatically pushed to this repository from [v0.app](https://v0.app). ## Deployment Your project is live at: **[https://vercel.com/jennasuddsca-8812s-projects/v0-tribe-oriented-appmain](https://vercel.com/jennasuddsca-8812s-projects/v0-tribe-oriented-appmain)** ## Build your app Continue building your app on: **[https://v0.app/chat/LKSfRKWUqiJ](https://v0.app/chat/LKSfRKWUqiJ)** ## How It Works 1. Create and modify your project using [v0.app](https://v0.app) 2. Deploy your chats from the v0 interface 3. Changes are automatically pushed to this repository 4. Vercel deploys the latest version from this repository [V0_FILE]typescriptreact:file="app/admin/page.tsx" "use client" import { useState } from "react" import { Button } from "@/components/ui/button" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { Input } from "@/components/ui/input" import { deleteAllTokens } from "@/lib/tokens" import { Trash2, ShieldX, Download, RefreshCw, Settings } from "lucide-react" import { useWallet } from "@/hooks/use-wallet" import { isAdmin } from "@/lib/admin-config" import { importTokensFromContract } from "@/lib/contract-import" import { setTokenBuySpread, setTokenSellSpread, emergencyWithdraw, setDexRouter, getTokenInfo, } from "@/lib/contract-functions" export default function AdminPage() { const [isDeleting, setIsDeleting] = useState(false) const [isImporting, setIsImporting] = useState(false) const [importMessage, setImportMessage] = useState("") const [message, setMessage] = useState("") const { address } = useWallet() const userIsAdmin = isAdmin(address) // Form states for admin functions const [tokenAddress, setTokenAddress] = useState("") const [spreadPercent, setSpreadPercent] = useState("") const [routerAddress, setRouterAddress] = useState("") const [adminMessage, setAdminMessage] = useState("") const [isLoading, setIsLoading] = useState(false) if (!address) { return (

Authentication Required

Please connect your wallet to access the admin panel.

) } if (!userIsAdmin) { return (

Access Denied

You do not have permission to access this page. Only authorized administrators can access the admin panel.

) } const handleSetBuySpread = async () => { if (!tokenAddress || !spreadPercent) { setAdminMessage("❌ Please enter token address and spread percent") return } setIsLoading(true) try { await setTokenBuySpread(tokenAddress, Number.parseInt(spreadPercent)) setAdminMessage("✅ Buy spread set successfully!") setTokenAddress("") setSpreadPercent("") } catch (error) { setAdminMessage(`❌ Error: ${error instanceof Error ? error.message : "Unknown error"}`) } finally { setIsLoading(false) } } const handleSetSellSpread = async () => { if (!tokenAddress || !spreadPercent) { setAdminMessage("❌ Please enter token address and spread percent") return } setIsLoading(true) try { await setTokenSellSpread(tokenAddress, Number.parseInt(spreadPercent)) setAdminMessage("✅ Sell spread set successfully!") setTokenAddress("") setSpreadPercent("") } catch (error) { setAdminMessage(`❌ Error: ${error instanceof Error ? error.message : "Unknown error"}`) } finally { setIsLoading(false) } } const handleEmergencyWithdraw = async () => { if (!tokenAddress) { setAdminMessage("❌ Please enter token address") return } setIsLoading(true) try { await emergencyWithdraw(tokenAddress) setAdminMessage("✅ Emergency withdrawal successful!") setTokenAddress("") } catch (error) { setAdminMessage(`❌ Error: ${error instanceof Error ? error.message : "Unknown error"}`) } finally { setIsLoading(false) } } const handleSetDexRouter = async () => { if (!routerAddress) { setAdminMessage("❌ Please enter router address") return } setIsLoading(true) try { await setDexRouter(routerAddress) setAdminMessage("✅ DEX router set successfully!") setRouterAddress("") } catch (error) { setAdminMessage(`❌ Error: ${error instanceof Error ? error.message : "Unknown error"}`) } finally { setIsLoading(false) } } const handleGetTokenInfo = async () => { if (!tokenAddress) { setAdminMessage("❌ Please enter token address") return } setIsLoading(true) try { const info = await getTokenInfo(tokenAddress) setAdminMessage(`✅ Token Info: Created by ${info.creator}, Completed: ${info.completed}`) } catch (error) { setAdminMessage(`❌ Error: ${error instanceof Error ? error.message : "Unknown error"}`) } finally { setIsLoading(false) } } const handleImportTokens = async () => { setIsImporting(true) setImportMessage("Fetching tokens from contract...") try { const result = await importTokensFromContract() if (result.success) { setImportMessage(`✅ Successfully imported ${result.imported} token(s). ${result.skipped} already existed.`) // Refresh page after 2 seconds setTimeout(() => { window.location.href = "/?t=" + Date.now() }, 2000) } else { setImportMessage(`❌ Failed to import tokens: ${result.error}`) } } catch (error) { console.error("Error importing tokens:", error) setImportMessage("❌ Error occurred while importing tokens") } finally { setIsImporting(false) } } const handleDeleteAllTokens = async () => { if (!confirm("⚠️ WARNING: This will permanently delete ALL tokens from the database. Are you sure?")) { return } if (!confirm("This action CANNOT be undone. Type DELETE in the next prompt to continue.")) { return } const confirmation = prompt("Type DELETE to confirm:") if (confirmation !== "DELETE") { setMessage("Deletion cancelled") return } setIsDeleting(true) setMessage("Deleting all tokens...") try { const success = await deleteAllTokens() if (success) { setMessage("✅ All tokens have been deleted successfully. Redirecting to homepage...") // Clear localStorage if (typeof window !== "undefined") { localStorage.removeItem("walletConnected") } // Reload page after 1 second with cache bypass setTimeout(() => { window.location.href = "/?t=" + Date.now() }, 1000) } else { setMessage("❌ Failed to delete tokens. Check console for errors.") } } catch (error) { console.error("Error deleting tokens:", error) setMessage("❌ Error occurred while deleting tokens") } finally { setIsDeleting(false) } } return (

Admin Panel

Import Tokens Import tokens from the blockchain contract

Import from Contract

This will fetch all tokens from the contract at 0xD9E849B6d44946B0D0FAEafe34b92C79c68cCbeF and add them to the database. Existing tokens will be skipped.

{importMessage && (

{importMessage}

)} Admin Settings Configure contract parameters

Set Token Buy Spread

setTokenAddress(e.target.value)} className="flex-1 text-sm" /> setSpreadPercent(e.target.value)} className="w-24 text-sm" />

Set Token Sell Spread

setTokenAddress(e.target.value)} className="flex-1 text-sm" /> setSpreadPercent(e.target.value)} className="w-24 text-sm" />

Emergency Withdrawal

setTokenAddress(e.target.value)} className="flex-1 text-sm" />

Set DEX Router

setRouterAddress(e.target.value)} className="flex-1 text-sm" />

Get Token Info

setTokenAddress(e.target.value)} className="flex-1 text-sm" />

{adminMessage && (

{adminMessage}

)} Legacy Contract Functions Deprecated admin functions from previous contract version

These functions were available in the previous contract and are no longer used. Please use the Admin Settings above instead.

Danger Zone Irreversible actions that affect the entire platform

Delete All Tokens

This will permanently delete all meme tokens from the database. This action cannot be undone. Use this before deploying a new contract.

{message && (

{message}

)}

Next Steps After Deletion

Update the contract address in lib/contract-config.ts
Replace the ABI in lib/contract-abi.json with your new contract's ABI
Test token creation with the new contract
Verify all trading functions work correctly

) } [V0_FILE]typescript:file="app/api/leaderboard/refresh/route.ts" import { NextResponse } from "next/server" import { createClient } from "@/lib/supabase/server" import { getTopTradersFromDB, getTopUsersByPoints } from "@/lib/leaderboard" export const runtime = "nodejs" export async function POST(request: Request) { try { console.log("[v0] Starting leaderboard refresh...") const [topTraders, mostActive] = await Promise.all([getTopTradersFromDB(25), getTopUsersByPoints(25)]) console.log("[v0] Fetched data:", { tradersCount: topTraders.length, activeCount: mostActive.length, }) const supabase = await createClient() if (!supabase) { throw new Error("Failed to create Supabase client") } // Update or insert top traders cache const { error: tradersError } = await supabase.from("leaderboard_cache").upsert( { cache_type: "top_traders", data: topTraders, last_updated: new Date().toISOString(), }, { onConflict: "cache_type", }, ) if (tradersError) { console.error("[v0] Error caching top traders:", tradersError.message) throw tradersError } // Update or insert most active cache const { error: activeError } = await supabase.from("leaderboard_cache").upsert( { cache_type: "most_active", data: mostActive, last_updated: new Date().toISOString(), }, { onConflict: "cache_type", }, ) if (activeError) { console.error("[v0] Error caching most active:", activeError.message) throw activeError } console.log("[v0] Leaderboard cache updated successfully") return NextResponse.json({ success: true, message: "Leaderboard refreshed successfully", timestamp: new Date().toISOString(), data: { topTraders: topTraders.length, mostActive: mostActive.length, }, }) } catch (error: any) { console.error("[v0] Error refreshing leaderboard:", error) return NextResponse.json( { success: false, error: error.message || "Failed to refresh leaderboard" }, { status: 500 }, ) } } // Auto-refresh on GET (for cron jobs) export async function GET() { return POST(new Request("http://localhost")) } [V0_FILE]typescriptreact:file="app/contract-diagnostics/page.tsx" "use client" import { useState, useEffect } from "react" import { ethers } from "ethers" import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card" import { Button } from "@/components/ui/button" import { CONTRACT_CONFIG } from "@/lib/contract-config" import CONTRACT_ABI from "@/lib/contract-abi.json" import { AlertTriangle, CheckCircle, XCircle, RefreshCw } from "lucide-react" import { getAllTokenAddresses } from "@/lib/contract-functions" export default function ContractDiagnosticsPage() { const [contractBalance, setContractBalance] = useState("Loading...") const [contractBalanceRaw, setContractBalanceRaw] = useState(BigInt(0)) const [treasuryAddress, setTreasuryAddress] = useState("Loading...") const [treasuryBalance, setTreasuryBalance] = useState("Loading...") const [ownerAddress, setOwnerAddress] = useState("Loading...") const [allTokens, setAllTokens] = useState([]) const [tokenDetails, setTokenDetails] = useState([]) const [totalTVT, setTotalTVT] = useState("Loading...") const [loading, setLoading] = useState(true) const [error, setError] = useState(null) const fetchDiagnostics = async () => { setLoading(true) setError(null) try { const provider = new ethers.JsonRpcProvider(CONTRACT_CONFIG.rpcUrl) const contract = new ethers.Contract(CONTRACT_CONFIG.address, CONTRACT_ABI, provider) // Get contract TRUST balance const balance = await provider.getBalance(CONTRACT_CONFIG.address) setContractBalanceRaw(balance) setContractBalance(ethers.formatEther(balance) + " TRUST") // Get treasury address and balance try { const treasury = await contract.treasuryAddress() setTreasuryAddress(treasury) const treasuryBal = await provider.getBalance(treasury) setTreasuryBalance(ethers.formatEther(treasuryBal) + " TRUST") } catch (e) { setTreasuryAddress("Error fetching treasury") setTreasuryBalance("N/A") } // Get owner address try { const owner = await contract.owner() setOwnerAddress(owner) } catch (e) { setOwnerAddress("N/A") } // Get total TVT try { const tvt = await contract.getTotalTVT() setTotalTVT(ethers.formatEther(tvt) + " TRUST") } catch (e) { setTotalTVT("N/A") } try { const tokens = await getAllTokenAddresses() setAllTokens(tokens) // Get details for each token const details = await Promise.all( tokens.slice(0, 20).map(async (tokenAddress: string) => { try { const info = await contract.getTokenInfo(tokenAddress) const isUnlocked = await contract.tokenUnlocked(tokenAddress) let tvt = "0" try { const tokenTvt = await contract.getTokenTVT(tokenAddress) tvt = ethers.formatEther(tokenTvt) } catch (e) { // getTokenTVT might not exist in old contract } return { address: tokenAddress, name: info.name, symbol: info.symbol, creator: info.creator, currentSupply: ethers.formatEther(info.currentSupply), maxSupply: ethers.formatEther(info.maxSupply), completed: info.completed, isUnlocked: isUnlocked, tvt: tvt, } } catch (e) { return { address: tokenAddress, error: String(e), } } }), ) setTokenDetails(details) } catch (e) { console.error("Error fetching tokens:", e) } } catch (e) { setError(String(e)) } finally { setLoading(false) } } useEffect(() => { fetchDiagnostics() }, []) const hasZeroBalance = contractBalanceRaw === BigInt(0) return (

Contract Security & Balance Diagnostics

{/* Critical Warning Banner */} {hasZeroBalance && !loading && (

Critical: Contract Has 0 TRUST Balance

The factory contract has no TRUST to pay sellers. This means ALL sell transactions will return 0 TRUST to users, even if they own tokens. The bonding curve requires incoming buys to fund outgoing sells.

)} {/* Contract Balance Card */} Contract Balances

Factory Contract Balance

{contractBalance}

{CONTRACT_CONFIG.address}

Treasury Balance (Fees)

{treasuryBalance}

{treasuryAddress}

Total Volume Traded (TVT)

{totalTVT}

Contract Owner

{ownerAddress}

{error &&

Error: {error}

} {/* Security Analysis Card */} Security Analysis

{hasZeroBalance ? ( ) : ( )} Contract has sufficient TRUST to pay sellers

Vercel/frontend cannot directly access smart contract funds

Only authorized functions can move contract funds

Check if owner/admin has called any withdrawal functions

Where Did the TRUST Go?

1. Seller withdrawals: When users sell tokens, TRUST leaves the contract
2. Treasury fees: 1% of each trade goes to treasury ({treasuryAddress})
3. Token migrations: When tokens complete, liquidity may be moved to DEX
4. Owner withdrawals: Check blockchain explorer for owner transactions

Recommended Actions

Check the blockchain explorer for recent transactions on the contract
Verify the treasury address received expected fees
Review if any admin/owner functions were called
Compare TVT (total volume) against expected contract balance

{/* Token Details Card */} Tokens on Contract ({allTokens.length} total)

{tokenDetails.length === 0 && !loading && (

No tokens found on contract

)} {tokenDetails.map((token, i) => (

{token.error ? (

Error loading token: {token.address}

) : (

{token.name} ({token.symbol})

{token.completed ? "Migrated" : token.isUnlocked ? "Unlocked" : "Locked"}

{token.address}

Supply:{" "} {Number.parseFloat(token.currentSupply).toLocaleString()} /{" "} {Number.parseFloat(token.maxSupply).toLocaleString()}

TVT: {token.tvt} TRUST

Creator:{" "} {token.creator}

)}

))}

{/* Explanation Card */} Understanding the Bonding Curve

The meme token launchpad uses a bonding curve model where the contract acts as an automated market maker (AMM).

When Users BUY

TRUST flows INTO the contract. Price increases.

When Users SELL

TRUST flows OUT of the contract. Price decreases.

If net sells exceed net buys, the contract balance depletes to zero. When balance is zero, the contract cannot pay sellers regardless of their token holdings.

Solution: The pool needs new buyers to send TRUST into the contract before sells can be honored.

) } [V0_FILE]typescriptreact:file="app/dex/page.tsx" "use client" import Header from "@/components/header" import Sidebar from "@/components/sidebar" import Footer from "@/components/footer" import { ArrowLeftRight, TrendingUp, Droplet } from "lucide-react" export default function DexPage() { return (

{}} />

DEX

Decentralized exchange functionality coming soon

Token Swaps

Trade TRIBE tokens directly with other users without intermediaries.

Liquidity Pools

Provide liquidity and earn rewards from trading fees.

Analytics

View detailed trading statistics and market insights.

) } [V0_FILE]typescriptreact:file="app/docs/page.tsx" "use client" import Header from "@/components/header" import Sidebar from "@/components/sidebar" import Footer from "@/components/footer" import { BookOpen, Code, Rocket, Shield } from "lucide-react" export default function DocsPage() { return (

{}} />

Documentation

Learn how to create and trade meme tokens on TRIBE

Getting Started

Connect your wallet and start creating or trading meme tokens


              Smart Contracts
              Learn about our bonding curve and tokenomics



            
              
              Security
              Understanding safety features and best practices
            

            
              
              API Reference
              Technical documentation for developers



          
            Quick Links
            
              • Contract Address: 0xD9E849B6d44946B0D0FAEafe34b92C79c68cCbeF
              • Network: Intuition Mainnet (Chain ID: 1155)
              • RPC URL: https://intuition.calderachain.xyz/http
              • Currency: TRUST


  )
}
[V0_FILE]typescriptreact:file="app/faq/page.tsx"
"use client"

import Header from "@/components/header"
import Sidebar from "@/components/sidebar"
import Footer from "@/components/footer"
import { HelpCircle, ChevronDown } from "lucide-react"
import { useState } from "react"

export default function FAQPage() {
  const [openIndex, setOpenIndex] = useState(null)

  const faqs = [
    {
      question: "What is TRIBE Launchpad?",
      answer:
        "TRIBE is a revolutionary meme coin trading platform built for meme, designed to empower anyone to create, trade, and verify meme coins with unparalleled transparency and trust. Powered by Intuition Graphs' decentralized infograph technology, TRIBE introduces a Reputation Graph to eliminate duplicates and ensure authenticity, fostering a secure and scalable environment for meme coin traders across Ethereum and major Layer-2 (L2) networks.",
    },
    {
      question: "How do I create a token?",
      answer:
        "Connect your wallet, click 'Create Token', fill in the token details (name, symbol, image), with no creation fee (Free). Your token will be instantly deployed on the blockchain.",
    },
    {
      question: "What is the bonding curve?",
      answer:
        "A bonding curve is a mathematical formula that determines the token price based on supply. As more tokens are bought, the price increases automatically.",
    },
    {
      question: "How do I earn points?",
      answer:
        "You can earn points by trading tokens, creating tokens, and adding comments. Points are tracked on your profile and leaderboard.",
    },
    {
      question: "What does the lock icon mean?",
      answer:
        "A locked token means the creator hasn't bought the required 2% of total supply yet. Once unlocked, anyone can trade the token.",
    },
    {
      question: "How do comments work?",
      answer:
        "You can comment on any token by visiting its detail page. Each comment costs 0.025 TRUST and earns you 0.025 points.",
    },
    {
      question: "Can anyone pass a DEX Migration proposal or any other proposal?",
      answer:
        "No. Only the MemeLaunchpad can initiate a proposal when certain conditions have been met on the bonding curve.",
    },
    {
      question: "Who can participate in a voting?",
      answer: "Anyone holding at least 100,000 units of the meme token on the Launchpad.",
    },
    {
      question: "Can a proposal be invalid?",
      answer:
        "Yes. If any of the following conditions are not met:\n\n• A total of >= 100 unique voters that participated in the proposal\n• A proposal that ends with no ties\n• A proposal that passes with the winning option receiving at least 59% of all votes",
    },
    {
      question: "Can the Creator sell tokens after unlocking it for trading on the bonding curve?",
      answer:
        "Yes. The creator can sell bought tokens on the bonding curve anytime. It is good to note that selling does not reduce creator bought amount. So the creator can sell before reaching 2% and the token will unlock once their cumulative purchases reach 2% even if the creator sold some bought tokens. Also, once a token is unlocked, it stays unlocked even if the creator sells all their bag on the bonding curve.",
    },
    {
      question: "How does TRIBE prevent a rug pull on DEX?",
      answer:
        "By introducing an LP lock logic. The LP is minted to the MemeLaunchpad contract which has no function that:\n\n• Transfers those LP tokens out\n• Approves the router to spend LP tokens or call any removeLiquidity function\n\nBecause only the contract itself (not the owner's EOA) can call approve/transfer on the LP token, and there is no such function exposed on the smart contract where the owner or anyone else can removeLiquidity or move LP tokens, therefore, LP is permanently locked forever.",
    },
  ]

  return (
    
      

      
         {}} />
        
          
            
              
              FAQ
            
            Frequently asked questions about TRIBE Launchpad
          

          
            {faqs.map((faq, index) => (
              
                
                {openIndex === index && (
                  
                    {faq.answer}
                  
                )}
              
            ))}
          

          
            Still have questions? Contact us through our community channels.
          
        

        
      
    
  )
}
[V0_FILE]css:file="app/globals.css"
@import "tailwindcss";
@import "tw-animate-css";

@custom-variant dark (&:is(.dark *));

:root {
  --background: oklch(0.08 0 0);
  --foreground: oklch(0.95 0 0);
  --card: oklch(0.12 0 0);
  --card-foreground: oklch(0.95 0 0);
  --popover: oklch(0.12 0 0);
  --popover-foreground: oklch(0.95 0 0);
  --primary: oklch(0.65 0.25 200);
  --primary-foreground: oklch(0.08 0 0);
  --secondary: oklch(0.5 0.05 0);
  --secondary-foreground: oklch(0.95 0 0);
  --muted: oklch(0.25 0 0);
  --muted-foreground: oklch(0.65 0 0);
  --accent: oklch(0.7 0.28 200);
  --accent-foreground: oklch(0.08 0 0);
  --destructive: oklch(0.577 0.245 27.325);
  --destructive-foreground: oklch(0.95 0 0);
  --border: oklch(0.2 0 0);
  --input: oklch(0.15 0 0);
  --ring: oklch(0.65 0.25 200);
  --chart-1: oklch(0.7 0.28 200);
  --chart-2: oklch(0.6 0.1 200);
  --chart-3: oklch(0.5 0.05 0);
  --chart-4: oklch(0.65 0.25 200);
  --chart-5: oklch(0.55 0.15 200);
  --radius: 0.625rem;
  --sidebar: oklch(0.1 0 0);
  --sidebar-foreground: oklch(0.95 0 0);
  --sidebar-primary: oklch(0.65 0.25 200);
  --sidebar-primary-foreground: oklch(0.08 0 0);
  --sidebar-accent: oklch(0.7 0.28 200);
  --sidebar-accent-foreground: oklch(0.08 0 0);
  --sidebar-border: oklch(0.2 0 0);
  --sidebar-ring: oklch(0.65 0.25 200);
}

.dark {
  --background: oklch(0.08 0 0);
  --foreground: oklch(0.95 0 0);
  --card: oklch(0.12 0 0);
  --card-foreground: oklch(0.95 0 0);
  --popover: oklch(0.12 0 0);
  --popover-foreground: oklch(0.95 0 0);
  --primary: oklch(0.65 0.25 200);
  --primary-foreground: oklch(0.08 0 0);
  --secondary: oklch(0.5 0.05 0);
  --secondary-foreground: oklch(0.95 0 0);
  --muted: oklch(0.25 0 0);
  --muted-foreground: oklch(0.65 0 0);
  --accent: oklch(0.7 0.28 200);
  --accent-foreground: oklch(0.08 0 0);
  --destructive: oklch(0.396 0.141 25.723);
  --destructive-foreground: oklch(0.95 0 0);
  --border: oklch(0.2 0 0);
  --input: oklch(0.15 0 0);
  --ring: oklch(0.65 0.25 200);
  --chart-1: oklch(0.7 0.28 200);
  --chart-2: oklch(0.6 0.1 200);
  --chart-3: oklch(0.5 0.05 0);
  --chart-4: oklch(0.65 0.25 200);
  --chart-5: oklch(0.55 0.15 200);
  --sidebar: oklch(0.1 0 0);
  --sidebar-foreground: oklch(0.95 0 0);
  --sidebar-primary: oklch(0.65 0.25 200);
  --sidebar-primary-foreground: oklch(0.08 0 0);
  --sidebar-accent: oklch(0.7 0.28 200);
  --sidebar-accent-foreground: oklch(0.08 0 0);
  --sidebar-border: oklch(0.2 0 0);
  --sidebar-ring: oklch(0.65 0.25 200);
}

@theme inline {
  --font-sans: "Geist", "Geist Fallback";
  --font-mono: "Geist Mono", "Geist Mono Fallback";
  --color-background: var(--background);
  --color-foreground: var(--foreground);
  --color-card: var(--card);
  --color-card-foreground: var(--card-foreground);
  --color-popover: var(--popover);
  --color-popover-foreground: var(--popover-foreground);
  --color-primary: var(--primary);
  --color-primary-foreground: var(--primary-foreground);
  --color-secondary: var(--secondary);
  --color-secondary-foreground: var(--secondary-foreground);
  --color-muted: var(--muted);
  --color-muted-foreground: var(--muted-foreground);
  --color-accent: var(--accent);
  --color-accent-foreground: var(--accent-foreground);
  --color-destructive: var(--destructive);
  --color-destructive-foreground: var(--destructive-foreground);
  --color-border: var(--border);
  --color-input: var(--input);
  --color-ring: var(--ring);
  --color-chart-1: var(--chart-1);
  --color-chart-2: var(--chart-2);
  --color-chart-3: var(--chart-3);
  --color-chart-4: var(--chart-4);
  --color-chart-5: var(--chart-5);
  --radius-sm: calc(var(--radius) - 4px);
  --radius-md: calc(var(--radius) - 2px);
  --radius-lg: var(--radius);
  --radius-xl: calc(var(--radius) + 4px);
  --color-sidebar: var(--sidebar);
  --color-sidebar-foreground: var(--sidebar-foreground);
  --color-sidebar-primary: var(--sidebar-primary);
  --color-sidebar-primary-foreground: var(--sidebar-primary-foreground);
  --color-sidebar-accent: var(--sidebar-accent);
  --color-sidebar-accent-foreground: var(--sidebar-accent-foreground);
  --color-sidebar-border: var(--sidebar-border);
  --color-sidebar-ring: var(--sidebar-ring);
}

@layer base {
  * {
    @apply border-border outline-ring/50;
  }
  html,
  body {
    @apply overflow-x-hidden;
  }
  body {
    @apply bg-background text-foreground;
  }
}

/* Hide scrollbars globally while still allowing scroll functionality */
.scrollbar-hide {
  -ms-overflow-style: none;
  scrollbar-width: none;
}

.scrollbar-hide::-webkit-scrollbar {
  display: none;
}

/* Hide scrollbar on all elements by default */
*::-webkit-scrollbar {
  width: 0;
  height: 0;
}

* {
  -ms-overflow-style: none;
  scrollbar-width: none;
}

@keyframes alpha-glow {
  0%,
  100% {
    box-shadow: 0 0 20px rgba(0, 200, 255, 0.3), inset 0 0 20px rgba(0, 200, 255, 0.1);
  }
  50% {
    box-shadow: 0 0 40px rgba(0, 200, 255, 0.5), inset 0 0 30px rgba(0, 200, 255, 0.2);
  }
}

@keyframes alpha-shimmer {
  0% {
    background-position: -1000px 0;
  }
  100% {
    background-position: 1000px 0;
  }
}

.alpha-glow {
  animation: alpha-glow 3s ease-in-out infinite;
}

.alpha-shimmer {
  background: linear-gradient(90deg, transparent, rgba(0, 200, 255, 0.2), transparent);
  background-size: 1000px 100%;
  animation: alpha-shimmer 3s infinite;
}

@keyframes marquee {
  0% {
    transform: translateX(0);
  }
  100% {
    transform: translateX(-50%);
  }
}

.animate-marquee {
  animation: marquee 30s linear infinite;
}

/* Admin input styling for better visibility */
input[type="text"],
input[type="number"],
input[type="email"],
input[type="password"],
input[type="url"],
textarea,
select {
  color: var(--foreground) !important;
  background-color: var(--input) !important;
  caret-color: var(--foreground) !important;
}

input::placeholder,
textarea::placeholder {
  color: var(--muted-foreground) !important;
  opacity: 0.7;
}

/* Ensure focus state is visible */
input:focus,
textarea:focus,
select:focus {
  outline: 2px solid var(--ring) !important;
  outline-offset: 2px;
}
[V0_FILE]typescriptreact:file="app/layout.tsx"
import type React from "react"
import type { Metadata } from "next"
import { Geist, Geist_Mono } from "next/font/google"
import "./globals.css"
import { SidebarProvider } from "@/components/sidebar"

const _geist = Geist({ subsets: ["latin"] })
const _geistMono = Geist_Mono({ subsets: ["latin"] })

export const metadata: Metadata = {
  title: "TRIBE - Meme Token Launchpad",
  description: "Launch and trade meme tokens on a bonding curve. Create your token with TRIBE.",
  generator: "v0.app",
}

export default function RootLayout({
  children,
}: Readonly<{
  children: React.ReactNode
}>) {
  return (
    
      
        {children}
      
    
  )
}
[V0_FILE]typescriptreact:file="app/leaderboard/page.tsx"
"use client"

import { useEffect, useState } from "react"
import Header from "@/components/header"
import Sidebar from "@/components/sidebar"
import Footer from "@/components/footer"
import { Trophy, Zap, RefreshCw } from "lucide-react"
import { getCachedLeaderboard, shouldRefreshCache, getMostActiveUsers, type LeaderboardUser } from "@/lib/leaderboard"
import { isAdmin } from "@/lib/admin-config"
import { useWallet } from "@/hooks/use-wallet"
import { Button } from "@/components/ui/button"

export default function LeaderboardPage() {
  const [mostActive, setMostActive] = useState([])
  const [loading, setLoading] = useState(true)
  const [refreshing, setRefreshing] = useState(false)
  const [lastUpdated, setLastUpdated] = useState(null)
  const { address } = useWallet()
  const isUserAdmin = address ? isAdmin(address) : false

  useEffect(() => {
    loadLeaderboards()
  }, [])

  const loadLeaderboards = async () => {
    setLoading(true)
    try {
      const activeCache = await getCachedLeaderboard("most_active")

      const needsActiveRefresh = shouldRefreshCache(activeCache?.last_updated)

      if (!needsActiveRefresh && activeCache?.data) {
        setMostActive(activeCache.data)
        setLastUpdated(activeCache.last_updated)
      }

      if (needsActiveRefresh) {
        console.log("[v0] Cache expired, triggering background refresh...")
        triggerBackgroundRefresh()

        if (!activeCache?.data) {
          const active = await getMostActiveUsers(25)
          setMostActive(active)
        }
      }
    } catch (error) {
      console.error("[v0] Error loading leaderboards:", error)
    } finally {
      setLoading(false)
    }
  }

  const triggerBackgroundRefresh = async () => {
    try {
      const response = await fetch("/api/leaderboard/refresh", {
        method: "POST",
      })

      if (response.ok) {
        console.log("[v0] Background refresh triggered successfully")
      }
    } catch (error) {
      console.error("[v0] Error triggering background refresh:", error)
    }
  }

  const handleManualRefresh = async () => {
    setRefreshing(true)
    try {
      const response = await fetch("/api/leaderboard/refresh", {
        method: "POST",
      })

      if (response.ok) {
        await loadLeaderboards()
      }
    } catch (error) {
      console.error("[v0] Error refreshing leaderboard:", error)
    } finally {
      setRefreshing(false)
    }
  }

  const formatAddress = (address: string) => {
    return `${address.slice(0, 6)}...${address.slice(-4)}`
  }

  const formatLastUpdated = (timestamp: string | null) => {
    if (!timestamp) return "Never"

    const date = new Date(timestamp)
    const now = new Date()
    const hoursAgo = Math.floor((now.getTime() - date.getTime()) / (1000 * 60 * 60))

    if (hoursAgo < 1) return "Less than 1 hour ago"
    if (hoursAgo === 1) return "1 hour ago"
    if (hoursAgo < 24) return `${hoursAgo} hours ago`

    const daysAgo = Math.floor(hoursAgo / 24)
    if (daysAgo === 1) return "1 day ago"
    return `${daysAgo} days ago`
  }

  return (
    
      

      
         {}} />
        
          
            
              
              Leaderboard
            
            Top performers on the TRIBE Launchpad

            
              Updates daily
              {lastUpdated && Last updated: {formatLastUpdated(lastUpdated)}}
              {isUserAdmin && (
                
              )}
            
          

          
            
              
                
                Most Active
              

              {loading ? (
                Loading users...
              ) : mostActive.length === 0 ? (
                
                  No activity yet
                  Trade tokens and post comments to earn points!
                
              ) : (
                
                  {mostActive.map((user) => (
                    
                      
                        #{user.rank}
                        
                          
                            {user.displayName || formatAddress(user.address)}
                          
                          {user.displayName && (
                            {formatAddress(user.address)}
                          )}
                        
                      
                      
                        {user.points.toFixed(2)} pts
                        
                          {user.tradingPoints.toFixed(2)} trading + {user.commentPoints.toFixed(2)} comments
                        
                      
                    
                  ))}
                
              )}
            
          
        

        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/page.tsx"
"use client"

import { useState, useEffect } from "react"
import Header from "@/components/header"
import Sidebar from "@/components/sidebar"
import CreateTokenModal from "@/components/create-token-modal"
import TokenGrid from "@/components/token-grid"
import BondingCurveView from "@/components/bonding-curve-view"
import Footer from "@/components/footer"
import TokenFilters, { type FilterType } from "@/components/token-filters"
import { fetchAllTokens } from "@/lib/tokens"
import { getStarredTokens } from "@/lib/starred-tokens"
import { useWallet } from "@/hooks/use-wallet"
import type { MemeToken } from "@/lib/tokens"
import TVTTicker from "@/components/tvt-ticker"
import WelcomeSplash from "@/components/welcome-splash"
import { HexagonalRating } from "@/components/hexagonal-rating"

export default function Home() {
  const [showCreateModal, setShowCreateModal] = useState(false)
  const [selectedToken, setSelectedToken] = useState(null)
  const [tokens, setTokens] = useState([])
  const [searchQuery, setSearchQuery] = useState("")
  const [showAlphaRoom, setShowAlphaRoom] = useState(false)
  const [isLoading, setIsLoading] = useState(true)
  const [loadError, setLoadError] = useState(null)
  const [activeFilter, setActiveFilter] = useState("all")
  const [starredTokenAddresses, setStarredTokenAddresses] = useState([])
  const [hoveredToken, setHoveredToken] = useState(null)
  const { address } = useWallet()
  const [showSplash, setShowSplash] = useState(() => {
    if (typeof window !== "undefined") {
      return !sessionStorage.getItem("splashSeen")
    }
    return true
  })

  useEffect(() => {
    loadTokens()
  }, [])

  useEffect(() => {
    if (address) {
      loadStarredTokens()
    }
  }, [address])

  useEffect(() => {
    if (tokens.length > 0 && !hoveredToken) {
      const nonRewindTokens = tokens.filter((t) => !t.isRewind2025)
      const sorted = [...nonRewindTokens].sort((a, b) => (b.marketCap || 0) - (a.marketCap || 0))
      if (sorted.length > 0) {
        setHoveredToken(sorted[0])
      }
    }
  }, [tokens, hoveredToken])

  const handleSplashEnter = () => {
    if (typeof window !== "undefined") {
      sessionStorage.setItem("splashSeen", "true")
    }
    setShowSplash(false)
  }

  const loadTokens = async () => {
    setIsLoading(true)
    setLoadError(null)
    try {
      if (!process.env.NEXT_PUBLIC_SUPABASE_URL || !process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY) {
        setLoadError("Database not configured. Please contact support.")
        setTokens([])
        return
      }

      const fetchedTokens = await fetchAllTokens()
      setTokens(fetchedTokens)
    } catch (error) {
      console.error("Failed to load tokens:", error)
      setLoadError("Failed to load tokens. Please refresh the page or try again later.")
      setTokens([])
    } finally {
      setIsLoading(false)
    }
  }

  const loadStarredTokens = async () => {
    if (!address) return

    try {
      const starred = await getStarredTokens(address)
      const normalizedStarred = starred.map((addr) => addr.toLowerCase())
      setStarredTokenAddresses(normalizedStarred)
    } catch (error) {
      console.error("Error loading starred tokens:", error)
    }
  }

  const handleCreateToken = (newToken: MemeToken) => {
    setTokens([newToken, ...tokens])
    setShowCreateModal(false)
  }

  const handleBackFromBondingCurve = () => {
    setSelectedToken(null)
    loadTokens()
  }

  const handleStarToggle = async () => {
    await loadStarredTokens()
  }

  const handleTokenHover = (token: MemeToken | null) => {
    if (token) {
      setHoveredToken(token)
    }
  }

  const getFilteredTokens = () => {
    let filtered = tokens

    if (searchQuery.trim()) {
      const query = searchQuery.toLowerCase()
      filtered = filtered.filter(
        (token) =>
          token.name.toLowerCase().includes(query) ||
          token.symbol.toLowerCase().includes(query) ||
          token.contractAddress.toLowerCase().includes(query),
      )
    }

    const now = new Date()
    const oneDayAgo = new Date(now.getTime() - 24 * 60 * 60 * 1000)

    switch (activeFilter) {
      case "rewind2025":
        filtered = filtered.filter((token) => token.isRewind2025 === true)
        filtered.sort((a, b) => new Date(b.createdAt!).getTime() - new Date(a.createdAt!).getTime())
        break
      case "tribe":
        filtered = filtered.filter((token) => {
          const hasIntuitionLink = token.intuitionLink && token.intuitionLink.trim() !== ""
          return hasIntuitionLink && !token.isRewind2025
        })
        break
      case "new":
        filtered = filtered.filter((token) => {
          if (!token.createdAt) return false
          const tokenDate = new Date(token.createdAt)
          return tokenDate.getTime() > oneDayAgo.getTime() && !token.isRewind2025
        })
        filtered.sort((a, b) => new Date(b.createdAt!).getTime() - new Date(a.createdAt!).getTime())
        break
      case "older":
        filtered = filtered.filter((token) => {
          if (!token.createdAt) return false
          const tokenDate = new Date(token.createdAt)
          return tokenDate.getTime() <= oneDayAgo.getTime() && !token.isRewind2025
        })
        filtered.sort((a, b) => new Date(a.createdAt!).getTime() - new Date(b.createdAt!).getTime())
        break
      case "starred":
        if (!address) {
          filtered = []
        } else {
          filtered = filtered.filter((token) => {
            const tokenAddr = token.contractAddress.toLowerCase()
            const isStarred = starredTokenAddresses.includes(tokenAddr)
            return isStarred && !token.isRewind2025
          })
        }
        break
      case "all":
      default:
        filtered = filtered.filter((token) => !token.isRewind2025)
        if (tokens.some((t) => t.createdAt)) {
          filtered.sort((a, b) => {
            const dateA = a.createdAt ? new Date(a.createdAt).getTime() : 0
            const dateB = b.createdAt ? new Date(b.createdAt).getTime() : 0
            return dateB - dateA
          })
        }
        break
    }

    return filtered
  }

  const filteredTokens = getFilteredTokens()

  const formatTimeAgo = (dateString: string | undefined) => {
    if (!dateString) return "N/A"
    const date = new Date(dateString)
    const now = new Date()
    const diffMs = now.getTime() - date.getTime()
    const diffMins = Math.floor(diffMs / 60000)
    const diffHours = Math.floor(diffMs / 3600000)
    const diffDays = Math.floor(diffMs / 86400000)

    if (diffMins < 60) return `${diffMins}m ago`
    if (diffHours < 24) return `${diffHours}h ago`
    return `${diffDays}d ago`
  }

  const getTokenStats = () => {
    if (!hoveredToken) return { totalHolders: 0, topHolderPercent: "0%", lastCreated: "N/A" }

    const totalHolders = hoveredToken.holders || 0
    const maxSupply = hoveredToken.maxSupply || 1000000000
    const currentSupply = hoveredToken.currentSupply || 0
    const topHolderEstimate = currentSupply > 0 ? Math.min(100, Math.round((currentSupply / maxSupply) * 100 * 0.4)) : 0

    return {
      totalHolders,
      topHolderPercent: `${topHolderEstimate}%`,
      lastCreated: formatTimeAgo(hoveredToken.createdAt),
    }
  }

  const tokenStats = getTokenStats()

  return (
    <>
      {showSplash && }
      
        
        
           setShowCreateModal(true)} onAlphaClick={() => setShowAlphaRoom(true)} />
          {selectedToken ? (
            
              
            
          ) : (
            
              
                
                  
                    
                  
                  
                    
                  
                  
                    
                      
                      
                         setSearchQuery(e.target.value)}
                          className="w-full px-4 py-2.5 pl-10 bg-card border-2 border-primary/50 rounded-lg text-foreground placeholder:text-muted-foreground focus:outline-none focus:border-primary shadow-[0_0_20px_rgba(234,179,8,0.3)] text-sm"
                        />
                        
                        {searchQuery && (
                          
                        )}
                      
                    
                    {searchQuery && (
                      
                        {filteredTokens.length} {filteredTokens.length === 1 ? "token" : "tokens"} found
                      
                    )}
                  
                
              
              
                
                  {hoveredToken ? (
                    
                  ) : (
                    
                      Hover over a token to see its rating
                    
                  )}
                  
                    Token Stats
                    
                      
                        Total Holders
                        {tokenStats.totalHolders}
                      
                      
                        Top Holder
                        {tokenStats.topHolderPercent}
                      
                      
                        Last Created
                        {tokenStats.lastCreated}
                      
                    
                  
                
              
              
                
                  {isLoading ? (
                    
                      Loading tokens...
                    
                  ) : loadError ? (
                    
                      {loadError}
                      
                    
                  ) : filteredTokens.length === 0 ? (
                    
                      
                        {searchQuery
                          ? "No tokens found matching your search"
                          : activeFilter === "starred"
                            ? address
                              ? "No starred tokens yet. Star your favorite tokens to see them here!"
                              : "Please connect your wallet to see starred tokens"
                            : activeFilter === "rewind2025"
                              ? "No Re-wind 2025 tokens available"
                              : "No tokens available"}
                      
                    
                  ) : (
                    
                  )}
                
                
                  {hoveredToken && (
                    
                      
                      
                        Token Stats
                        
                          
                            Total Holders
                            {tokenStats.totalHolders}
                          
                          
                            Top Holder
                            {tokenStats.topHolderPercent}
                          
                          
                            Last Created
                            {tokenStats.lastCreated}
                          
                        
                      
                    
                  )}
                
              
            
          )}
          
          {showCreateModal && (
             setShowCreateModal(false)}
              onCreate={handleCreateToken}
              existingTokens={tokens}
            />
          )}
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/portfolio/page.tsx"
"use client"

import { useState, useEffect } from "react"
import { useWallet } from "@/hooks/use-wallet"
import { fetchAllTokens, type MemeToken } from "@/lib/tokens"
import { getUserTokenBalance } from "@/lib/user-holdings"
import { getUserPoints, updateUserPoints } from "@/lib/points-system"
import { Card } from "@/components/ui/card"
import { Button } from "@/components/ui/button"
import { ArrowLeft, TrendingUp, Coins, Award, RefreshCw, AlertCircle } from "lucide-react"
import { useRouter } from "next/navigation"

interface TokenHolding extends MemeToken {
  balance: string
  value: number
}

export default function PortfolioPage() {
  const { address } = useWallet()
  const router = useRouter()
  const [holdings, setHoldings] = useState([])
  const [createdTokens, setCreatedTokens] = useState([])
  const [isLoading, setIsLoading] = useState(true)
  const [totalValue, setTotalValue] = useState(0)

  const [userPoints, setUserPoints] = useState(0)
  const [totalVolume, setTotalVolume] = useState(0)
  const [isRefreshingPoints, setIsRefreshingPoints] = useState(false)
  const [pointsTableMissing, setPointsTableMissing] = useState(false)

  useEffect(() => {
    const loadPortfolio = async () => {
      if (!address) {
        setIsLoading(false)
        return
      }

      setIsLoading(true)
      try {
        const allTokens = await fetchAllTokens()

        const created = allTokens.filter((token) => token.creator.toLowerCase() === address.toLowerCase())
        setCreatedTokens(created)

        const holdingsPromises = allTokens.map(async (token) => {
          if (!token.contractAddress) return null

          const balance = await getUserTokenBalance(token.contractAddress, address)
          const balanceNum = Number.parseFloat(balance)

          if (balanceNum > 0) {
            const value = balanceNum * (token.currentPrice || 0)
            return { ...token, balance, value }
          }
          return null
        })

        const resolvedHoldings = (await Promise.all(holdingsPromises)).filter((h): h is TokenHolding => h !== null)
        setHoldings(resolvedHoldings)

        const total = resolvedHoldings.reduce((sum, holding) => sum + holding.value, 0)
        setTotalValue(total)

        const points = await getUserPoints(address)
        if (points) {
          setUserPoints(points.points)
          setTotalVolume(points.totalVolume)
          setPointsTableMissing(false)
        } else {
          setPointsTableMissing(true)
        }
      } catch (error) {
        console.error("[v0] Error loading portfolio:", error)
      } finally {
        setIsLoading(false)
      }
    }

    loadPortfolio()
  }, [address])

  const handleRefreshPoints = async () => {
    if (!address) return

    setIsRefreshingPoints(true)
    try {
      const result = await updateUserPoints(address)
      if (result) {
        setUserPoints(result.points)
        setTotalVolume(result.totalVolume)
      }
    } catch (error) {
      console.error("[v0] Error refreshing points:", error)
    } finally {
      setIsRefreshingPoints(false)
    }
  }

  if (!address) {
    return (
      
        
          Portfolio
          Connect your wallet to view your portfolio
        
      
    )
  }

  return (
    
      
        

        
          
            
              
                Total Portfolio Value
                {totalValue.toFixed(2)} TRUST
                Based on current market prices
              
            

            
              
                
                  
                    
                    Trading Points
                  
                  
                
                {userPoints.toFixed(2)}
                {totalVolume.toFixed(2)} TRUST Total Volume
                {pointsTableMissing && (
                  
                    
                    
                      Points are calculated from blockchain but not persisted. Run the migration script to enable full
                      points tracking.
                    
                  
                )}
              
            
          

          
            
              
              Your Holdings
            

            {isLoading ? (
              
                Loading your holdings...
              
            ) : holdings.length > 0 ? (
              
                {holdings.map((holding) => (
                  
                    
                      
                      
                        {holding.name}
                        ${holding.symbol}
                      
                    

                    
                      
                        Balance
                        
                          {Number.parseFloat(holding.balance).toFixed(2)}
                        
                      
                      
                        Value
                        {holding.value.toFixed(2)} TRUST
                      
                      
                        Price
                        ${holding.currentPrice?.toFixed(8)}
                      
                    

                    
                  
                ))}
              
            ) : (
              
                You don't hold any tokens yet
              
            )}
          

          
            
              
              Tokens You Created
            

            {isLoading ? (
              
                Loading your tokens...
              
            ) : createdTokens.length > 0 ? (
              
                {createdTokens.map((token) => (
                  
                    
                      
                      
                        {token.name}
                        ${token.symbol}
                      
                    

                    
                      
                        Market Cap
                        
                          ${((token.marketCap || 0) / 1000000).toFixed(2)}M
                        
                      
                      
                        Current Price
                        ${token.currentPrice?.toFixed(8)}
                      
                    

                    
                  
                ))}
              
            ) : (
              
                You haven't created any tokens yet
              
            )}
          
        
      
    
  )
}
[V0_FILE]typescriptreact:file="app/settings/page.tsx"
"use client"

import type React from "react"

import { useState, useEffect, useRef } from "react"
import { useWallet } from "@/hooks/use-wallet"
import { getUserProfile, createOrUpdateUserProfile, type UserProfile } from "@/lib/user-profiles"
import Header from "@/components/header"
import { Card } from "@/components/ui/card"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { Textarea } from "@/components/ui/textarea"
import { ArrowLeft, User, Loader2, Upload, X } from "lucide-react"
import { useRouter } from "next/navigation"
import { createBrowserClient } from "@/lib/supabase/client"

export default function SettingsPage() {
  const { address } = useWallet()
  const router = useRouter()
  const fileInputRef = useRef(null)
  const [profile, setProfile] = useState(null)
  const [displayName, setDisplayName] = useState("")
  const [bio, setBio] = useState("")
  const [profileImage, setProfileImage] = useState("")
  const [previewImage, setPreviewImage] = useState(null)
  const [isLoading, setIsLoading] = useState(true)
  const [isSaving, setIsSaving] = useState(false)
  const [isUploading, setIsUploading] = useState(false)
  const [message, setMessage] = useState<{ type: "success" | "error"; text: string } | null>(null)

  useEffect(() => {
    const loadProfile = async () => {
      if (!address) {
        setIsLoading(false)
        return
      }

      setIsLoading(true)
      try {
        const userProfile = await getUserProfile(address)
        if (userProfile) {
          setProfile(userProfile)
          setDisplayName(userProfile.display_name || "")
          setBio(userProfile.bio || "")
          setProfileImage(userProfile.profile_image || "")
        }
      } catch (error) {
        console.error("[v0] Error loading profile:", error)
      } finally {
        setIsLoading(false)
      }
    }

    loadProfile()
  }, [address])

  const handleImageSelect = async (e: React.ChangeEvent) => {
    const file = e.target.files?.[0]
    if (!file) return

    // Validate file type
    const validTypes = ["image/jpeg", "image/jpg", "image/png", "image/gif", "image/webp"]
    if (!validTypes.includes(file.type)) {
      setMessage({ type: "error", text: "Please upload a JPG, PNG, GIF, or WebP image." })
      return
    }

    // Validate file size (max 5MB)
    const maxSize = 5 * 1024 * 1024 // 5MB
    if (file.size > maxSize) {
      setMessage({ type: "error", text: "Image too large. Maximum size is 5MB." })
      return
    }

    // Create preview
    const reader = new FileReader()
    reader.onload = (event) => {
      setPreviewImage(event.target?.result as string)
    }
    reader.readAsDataURL(file)

    setIsUploading(true)
    setMessage(null)

    try {
      const supabase = createBrowserClient()

      // Generate unique filename
      const timestamp = Date.now()
      const randomString = Math.random().toString(36).substring(2, 15)
      const fileExt = file.name.split(".").pop()
      const fileName = `profile-${timestamp}-${randomString}.${fileExt}`

      // Upload to Supabase Storage
      const { data, error } = await supabase.storage.from("profile-images").upload(fileName, file, {
        contentType: file.type,
        upsert: false,
      })

      if (error) {
        console.error("[v0] Upload error:", error)
        throw new Error(error.message)
      }

      // Get public URL
      const { data: publicUrlData } = supabase.storage.from("profile-images").getPublicUrl(data.path)

      setProfileImage(publicUrlData.publicUrl)
      setMessage({ type: "success", text: "Image uploaded successfully!" })
    } catch (error) {
      console.error("[v0] Error uploading image:", error)
      setMessage({ type: "error", text: error instanceof Error ? error.message : "Failed to upload image" })
      setPreviewImage(null)
    } finally {
      setIsUploading(false)
    }
  }

  const handleClearImage = () => {
    setProfileImage("")
    setPreviewImage(null)
    if (fileInputRef.current) {
      fileInputRef.current.value = ""
    }
  }

  const handleSaveProfile = async () => {
    if (!address) return

    setIsSaving(true)
    setMessage(null)

    try {
      const updatedProfile = await createOrUpdateUserProfile({
        wallet_address: address,
        display_name: displayName,
        bio: bio,
        profile_image: profileImage,
      })

      setProfile(updatedProfile)
      setMessage({ type: "success", text: "Profile saved successfully!" })
    } catch (error) {
      console.error("[v0] Error saving profile:", error)
      setMessage({ type: "error", text: "Failed to save profile. Please try again." })
    } finally {
      setIsSaving(false)
    }
  }

  if (!address) {
    return (
      
         {}} />
        
          Settings
          Connect your wallet to access settings
        
      
    )
  }

  return (
    
       {}} />
      
        

        
          
            
            Profile Settings
          

          {isLoading ? (
            
              Loading profile...
            
          ) : (
            
              {/* Profile Image */}
              
                Profile Image
                
                  
                    {previewImage || profileImage ? (
                      
                    ) : (
                      
                    )}
                  
                  
                    
                    
                      
                      {(profileImage || previewImage) && (
                        
                      )}
                    
                    Upload JPG, PNG, GIF, or WebP (max 5MB)
                  
                
              

              {/* Display Name */}
              
                Display Name
                 setDisplayName(e.target.value)}
                  className="bg-input border-border text-foreground"
                />
              

              {/* Bio */}
              
                Bio
                 setBio(e.target.value)}
                  className="bg-input border-border text-foreground min-h-[120px]"
                />
              </div>

              {/* Wallet Address (Read-only) */}
              <div className="space-y-3">
                <label className="text-sm font-semibold text-foreground">Wallet Address</label>
                <Input value={address} disabled className="bg-muted/30 border-border text-muted-foreground" />
              </div>

              {/* Save Button */}
              <div className="pt-4">
                <Button
                  onClick={handleSaveProfile}
                  disabled={isSaving || isUploading}
                  className="w-full bg-primary hover:bg-primary/90 text-primary-foreground py-6 text-lg font-semibold"
                >
                  {isSaving ? (
                    <>
                      <Loader2 className="w-5 h-5 mr-2 animate-spin" />
                      Saving...
                    </>
                  ) : (
                    "Save Profile"
                  )}
                </Button>
              </div>

              {/* Success/Error Message */}
              {message && (
                <div
                  className={`p-4 rounded-lg ${
                    message.type === "success"
                      ? "bg-green-500/10 border border-green-500/30 text-green-400"
                      : "bg-red-500/10 border border-red-500/30 text-red-400"
                  }`}
                >
                  {message.text}
                </div>
              )}
            </Card>
          )}
        </div>
      </div>
    </main>
  )
}
[V0_FILE]typescriptreact:file="app/test-create/page.tsx"
"use client"

import { useState } from "react"
import { Button } from "@/components/ui/button"
import { Card } from "@/components/ui/card"
import { createTokenInDatabase } from "@/lib/tokens"
import { useWallet } from "@/hooks/use-wallet"

export default function TestCreatePage() {
  const [result, setResult] = useState<string>("")
  const [loading, setLoading] = useState(false)
  const { address } = useWallet()

  const handleTestCreate = async () => {
    setLoading(true)
    setResult("Testing...")

    try {
      if (!address) {
        setResult("ERROR: No wallet connected")
        setLoading(false)
        return
      }

      const testToken = {
        name: "Test Token",
        symbol: "TEST",
        image: "/meme-token.jpg",
        currentPrice: 0.0001533,
        startPrice: 0.0001533,
        marketCap: 0,
        maxSupply: 1000000000,
        currentSupply: 0,
        holders: 1,
        creator: address,
        intuitionLink: "",
        isAlpha: true,
        contractAddress: `0xTEST${Date.now()}`,
        isCompleted: false,
        createdAt: new Date().toISOString(),
      }

      console.log("[v0 TEST] Calling createTokenInDatabase with:", testToken)
      const savedToken = await createTokenInDatabase(testToken)

      if (savedToken) {
        setResult(`SUCCESS! Token created with ID: ${savedToken.id}`)
      } else {
        setResult("ERROR: createTokenInDatabase returned null - check console for details")
      }
    } catch (error) {
      setResult(`ERROR: ${error instanceof Error ? error.message : String(error)}`)
      console.error("[v0 TEST] Error:", error)
    } finally {
      setLoading(false)
    }
  }

  return (
    <div className="min-h-screen p-8">
      <Card className="max-w-2xl mx-auto p-6 space-y-4">
        <h1 className="text-2xl font-bold">Database Insert Test</h1>
        <p className="text-muted-foreground">
          This page directly tests the createTokenInDatabase function to diagnose why tokens aren't being saved.
        </p>

        <div className="space-y-2">
          <p className="text-sm">Wallet: {address || "Not connected"}</p>
          <Button onClick={handleTestCreate} disabled={loading || !address}>
            {loading ? "Testing..." : "Test Create Token"}
          </Button>
        </div>

        {result && (
          <div
            className={`p-4 rounded-lg ${result.startsWith("SUCCESS") ? "bg-green-500/10 border border-green-500/30" : "bg-red-500/10 border border-red-500/30"}`}
          >
            <pre className="text-sm whitespace-pre-wrap">{result}</pre>
          </div>
        )}

        <div className="text-xs text-muted-foreground">
          <p>Check the browser console for detailed logs.</p>
        </div>
      </Card>
    </div>
  )
}
[V0_FILE]typescriptreact:file="app/vote/page.tsx"
"use client"

import { useState, useEffect } from "react"
import { useWallet } from "@/hooks/use-wallet"
import { isAdmin } from "@/lib/admin-config"
import { Button } from "@/components/ui/button"
import { Card, CardContent, CardHeader, CardTitle, CardDescription } from "@/components/ui/card"
import { Input } from "@/components/ui/input"
import { Textarea } from "@/components/ui/textarea"
import { Badge } from "@/components/ui/badge"
import {
  Plus,
  ThumbsUp,
  ThumbsDown,
  Users,
  Clock,
  CheckCircle,
  XCircle,
  Loader2,
  Shield,
  Timer,
  AlertCircle,
} from "lucide-react"
import {
  getAllProposals,
  createProposal,
  castVote,
  hasUserVoted,
  checkTokenHolding,
  addToWhitelist,
  removeFromWhitelist,
  getProposalWhitelist,
  closeProposal,
  checkProposalValidity,
  type VotingProposal,
  type WhitelistedAddress,
  type ProposalValidityResult,
} from "@/lib/voting"
import Sidebar from "@/components/sidebar"
import Header from "@/components/header"

export default function VotePage() {
  const { address, isConnected } = useWallet()
  const [proposals, setProposals] = useState<VotingProposal[]>([])
  const [loading, setLoading] = useState(true)
  const [showCreateForm, setShowCreateForm] = useState(false)
  const [creating, setCreating] = useState(false)
  const [votingStates, setVotingStates] = useState<Record<string, boolean>>({})
  const [userVotedMap, setUserVotedMap] = useState<Record<string, boolean>>({})
  const [eligibilityMap, setEligibilityMap] = useState<Record<string, boolean>>({})
  const [validityMap, setValidityMap] = useState<Record<string, ProposalValidityResult>>({})
  const [, setTimeUpdate] = useState(0)
  const [newTitle, setNewTitle] = useState("")
  const [newDescription, setNewDescription] = useState("")
  const [newTokenAddress, setNewTokenAddress] = useState("")
  const [selectedProposal, setSelectedProposal] = useState<string | null>(null)
  const [loadingWhitelist, setLoadingWhitelist] = useState(false)
  const [whitelist, setWhitelist] = useState<WhitelistedAddress[]>([])
  const [whitelistAddress, setWhitelistAddress] = useState("")

  useEffect(() => {
    loadProposals()
  }, [])

  useEffect(() => {
    const interval = setInterval(() => {
      setTimeUpdate((prev) => prev + 1)
    }, 60000) // Update every minute

    return () => clearInterval(interval)
  }, [])

  useEffect(() => {
    if (address && proposals.length > 0) {
      checkUserVotes()
      checkEligibility()
    }
  }, [address, proposals])

  useEffect(() => {
    if (proposals.length > 0) {
      checkProposalValidities()
    }
  }, [proposals])

  async function loadProposals() {
    setLoading(true)
    const data = await getAllProposals()
    setProposals(data)
    setLoading(false)
  }

  async function checkProposalValidities() {
    const validities: Record<string, ProposalValidityResult> = {}
    for (const proposal of proposals) {
      const timeRemaining = getTimeRemaining(proposal.ends_at)
      const isExpired = timeRemaining.expired || proposal.status === "closed"

      if (isExpired) {
        validities[proposal.id] = await checkProposalValidity(proposal)
      }
    }
    setValidityMap(validities)
  }

  async function checkUserVotes() {
    if (!address) return

    const voteMap: Record<string, boolean> = {}
    for (const proposal of proposals) {
      voteMap[proposal.id] = await hasUserVoted(proposal.id, address)
    }
    setUserVotedMap(voteMap)
  }

  async function checkEligibility() {
    if (!address) return

    const eligibility: Record<string, boolean> = {}
    for (const proposal of proposals) {
      eligibility[proposal.id] = await checkTokenHolding(proposal.token_address, address)
    }
    setEligibilityMap(eligibility)
  }

  async function handleCreateProposal() {
    if (!address || !newTitle || !newDescription || !newTokenAddress) return

    setCreating(true)
    const proposal = await createProposal(newTitle, newDescription, newTokenAddress, address)

    if (proposal) {
      setProposals([proposal, ...proposals])
      setNewTitle("")
      setNewDescription("")
      setNewTokenAddress("")
      setShowCreateForm(false)
    }
    setCreating(false)
  }

  async function handleVote(proposalId: string, vote: "yes" | "no", tokenAddress: string) {
    if (!address) return

    setVotingStates({ ...votingStates, [proposalId]: true })

    const result = await castVote(proposalId, address, vote, tokenAddress)

    if (result.success) {
      await loadProposals()
      setUserVotedMap({ ...userVotedMap, [proposalId]: true })
    } else {
      alert(result.error || "Failed to cast vote")
    }

    setVotingStates({ ...votingStates, [proposalId]: false })
  }

  async function handleLoadWhitelist(proposalId: string) {
    setSelectedProposal(proposalId)
    setLoadingWhitelist(true)
    const data = await getProposalWhitelist(proposalId)
    setWhitelist(data)
    setLoadingWhitelist(false)
  }

  async function handleAddToWhitelist() {
    if (!selectedProposal || !whitelistAddress) return

    const success = await addToWhitelist(selectedProposal, whitelistAddress)
    if (success) {
      await handleLoadWhitelist(selectedProposal)
      setWhitelistAddress("")
    }
  }

  async function handleRemoveFromWhitelist(walletAddress: string) {
    if (!selectedProposal) return

    const success = await removeFromWhitelist(selectedProposal, walletAddress)
    if (success) {
      await handleLoadWhitelist(selectedProposal)
    }
  }

  async function handleCloseProposal(proposalId: string) {
    const success = await closeProposal(proposalId)
    if (success) {
      await loadProposals()
    }
  }

  function formatAddress(addr: string): string {
    return `${addr.slice(0, 6)}...${addr.slice(-4)}`
  }

  function getVotePercentage(yesVotes: number, noVotes: number): { yes: number; no: number } {
    const total = yesVotes + noVotes
    if (total === 0) return { yes: 0, no: 0 }
    return {
      yes: Math.round((yesVotes / total) * 100),
      no: Math.round((noVotes / total) * 100),
    }
  }

  function getTimeRemaining(endsAt: string | null): { text: string; expired: boolean } {
    if (!endsAt) return { text: "No end date", expired: false }

    const now = new Date()
    const end = new Date(endsAt)
    const diff = end.getTime() - now.getTime()

    if (diff <= 0) {
      return { text: "Voting ended", expired: true }
    }

    const hours = Math.floor(diff / (1000 * 60 * 60))
    const minutes = Math.floor((diff % (1000 * 60 * 60)) / (1000 * 60))

    if (hours >= 24) {
      const days = Math.floor(hours / 24)
      const remainingHours = hours % 24
      return { text: `${days}d ${remainingHours}h remaining`, expired: false }
    }

    return { text: `${hours}h ${minutes}m remaining`, expired: false }
  }

  return (
    <div className="min-h-screen bg-background">
      <Sidebar />
      <Header />

      <main className="ml-16 pt-28 p-4 md:p-6">
        <div className="max-w-4xl mx-auto">
          <div className="flex items-center justify-between mb-6">
            <div>
              <h1 className="text-2xl font-bold text-foreground">Voting</h1>
              <p className="text-sm text-muted-foreground">Vote on community proposals (72-hour voting period)</p>
            </div>

            {isAdmin(address) && (
              <Button onClick={() => setShowCreateForm(!showCreateForm)} className="bg-primary hover:bg-primary/90">
                <Plus className="w-4 h-4 mr-2" />
                Create Proposal
              </Button>
            )}
          </div>

          {/* Create Proposal Form (Admin Only) */}
          {showCreateForm && isAdmin(address) && (
            <Card className="mb-6 border-primary/50">
              <CardHeader>
                <CardTitle className="text-lg">Create New Proposal</CardTitle>
                <CardDescription>Voting will automatically end after 72 hours</CardDescription>
              </CardHeader>
              <CardContent className="space-y-4">
                <div>
                  <label className="text-sm font-medium text-foreground mb-1 block">Title</label>
                  <Input value={newTitle} onChange={(e) => setNewTitle(e.target.value)} placeholder="Proposal title" />
                </div>
                <div>
                  <label className="text-sm font-medium text-foreground mb-1 block">Description</label>
                  <Textarea
                    value={newDescription}
                    onChange={(e) => setNewDescription(e.target.value)}
                    placeholder="Describe the proposal in detail..."
                    rows={4}
                  />
                </div>
                <div>
                  <label className="text-sm font-medium text-foreground mb-1 block">Token Address</label>
                  <Input
                    value={newTokenAddress}
                    onChange={(e) => setNewTokenAddress(e.target.value)}
                    placeholder="0x..."
                  />
                  <p className="text-xs text-muted-foreground mt-1">The meme coin token address for this proposal</p>
                </div>
                <div className="flex gap-2">
                  <Button
                    onClick={handleCreateProposal}
                    disabled={creating || !newTitle || !newDescription || !newTokenAddress}
                    className="bg-primary hover:bg-primary/90"
                  >
                    {creating ? (
                      <>
                        <Loader2 className="w-4 h-4 mr-2 animate-spin" />
                        Creating...
                      </>
                    ) : (
                      "Create Proposal"
                    )}
                  </Button>
                  <Button variant="outline" onClick={() => setShowCreateForm(false)}>
                    Cancel
                  </Button>
                </div>
              </CardContent>
            </Card>
          )}

          {/* Whitelist Management Modal (Admin Only) */}
          {selectedProposal && isAdmin(address) && (
            <Card className="mb-6 border-yellow-500/50">
              <CardHeader>
                <CardTitle className="text-lg flex items-center gap-2">
                  <Shield className="w-5 h-5 text-yellow-500" />
                  Whitelist Management (20x Voting Power)
                </CardTitle>
                <CardDescription>Add creator addresses to give them 20x voting power</CardDescription>
              </CardHeader>
              <CardContent className="space-y-4">
                <div className="flex gap-2">
                  <Input
                    value={whitelistAddress}
                    onChange={(e) => setWhitelistAddress(e.target.value)}
                    placeholder="Creator wallet address (0x...)"
                    className="flex-1"
                  />
                  <Button onClick={handleAddToWhitelist} disabled={!whitelistAddress}>
                    Add
                  </Button>
                </div>

                {loadingWhitelist ? (
                  <div className="flex items-center justify-center py-4">
                    <Loader2 className="w-5 h-5 animate-spin text-muted-foreground" />
                  </div>
                ) : whitelist.length > 0 ? (
                  <div className="space-y-2">
                    {whitelist.map((item) => (
                      <div key={item.id} className="flex items-center justify-between p-2 bg-muted rounded-lg">
                        <span className="text-sm font-mono">{formatAddress(item.wallet_address)}</span>
                        <Button
                          size="sm"
                          variant="destructive"
                          onClick={() => handleRemoveFromWhitelist(item.wallet_address)}
                        >
                          Remove
                        </Button>
                      </div>
                    ))}
                  </div>
                ) : (
                  <p className="text-sm text-muted-foreground text-center py-2">No whitelisted addresses yet</p>
                )}

                <Button variant="outline" onClick={() => setSelectedProposal(null)} className="w-full">
                  Close
                </Button>
              </CardContent>
            </Card>
          )}

          {/* Proposals List */}
          {loading ? (
            <div className="flex items-center justify-center py-12">
              <Loader2 className="w-8 h-8 animate-spin text-primary" />
            </div>
          ) : proposals.length === 0 ? (
            <Card>
              <CardContent className="py-12 text-center">
                <p className="text-muted-foreground">No proposals yet</p>
              </CardContent>
            </Card>
          ) : (
            <div className="space-y-4">
              {proposals.map((proposal) => {
                const percentages = getVotePercentage(proposal.yes_voting_power, proposal.no_voting_power)
                const isVoting = votingStates[proposal.id]
                const hasVoted = userVotedMap[proposal.id]
                const isEligible = eligibilityMap[proposal.id]
                const isClosed = proposal.status === "closed"
                const timeRemaining = getTimeRemaining(proposal.ends_at)
                const isExpired = timeRemaining.expired || isClosed
                const validity = validityMap[proposal.id]

                return (
                  <Card key={proposal.id} className={isExpired ? "opacity-75" : ""}>
                    <CardHeader>
                      <div className="flex items-start justify-between">
                        <div className="flex-1">
                          <div className="flex items-center gap-2 mb-1 flex-wrap">
                            <CardTitle className="text-lg">{proposal.title}</CardTitle>
                            <Badge variant={isExpired ? "secondary" : "default"}>
                              {isClosed ? "Closed" : timeRemaining.expired ? "Ended" : "Active"}
                            </Badge>
                            {isExpired && validity && (
                              <Badge
                                variant={validity.isValid ? "default" : "destructive"}
                                className={validity.isValid ? "bg-green-600 hover:bg-green-700" : ""}
                              >
                                {validity.isValid ? (
                                  <>
                                    <CheckCircle className="w-3 h-3 mr-1" />
                                    Valid
                                  </>
                                ) : (
                                  <>
                                    <AlertCircle className="w-3 h-3 mr-1" />
                                    Invalid
                                  </>
                                )}
                              </Badge>
                            )}
                          </div>
                          <CardDescription className="text-xs">
                            Token: {formatAddress(proposal.token_address)}
                          </CardDescription>
                        </div>

                        {isAdmin(address) && !isExpired && (
                          <div className="flex gap-2">
                            <Button size="sm" variant="outline" onClick={() => handleLoadWhitelist(proposal.id)}>
                              <Shield className="w-4 h-4" />
                            </Button>
                            <Button size="sm" variant="destructive" onClick={() => handleCloseProposal(proposal.id)}>
                              Close
                            </Button>
                          </div>
                        )}
                      </div>
                    </CardHeader>
                    <CardContent className="space-y-4">
                      <p className="text-sm text-foreground">{proposal.description}</p>

                      <div className="space-y-2">
                        <div className="flex justify-between text-sm">
                          <span className="flex items-center gap-1 text-green-500">
                            <ThumbsUp className="w-4 h-4" />
                            Yes: {proposal.yes_voting_power} ({percentages.yes}%)
                          </span>
                          <span className="flex items-center gap-1 text-red-500">
                            No: {proposal.no_voting_power} ({percentages.no}%)
                            <ThumbsDown className="w-4 h-4" />
                          </span>
                        </div>
                        <div className="h-3 bg-muted rounded-full overflow-hidden flex">
                          <div
                            className="bg-green-500 transition-all duration-300"
                            style={{ width: `${percentages.yes}%` }}
                          />
                          <div
                            className="bg-red-500 transition-all duration-300"
                            style={{ width: `${percentages.no}%` }}
                          />
                        </div>
                        <div className="flex items-center justify-between text-xs text-muted-foreground">
                          <div className="flex items-center gap-4">
                            <span className="flex items-center gap-1">
                              <Users className="w-3 h-3" />
                              {proposal.yes_voting_power + proposal.no_voting_power} voting power (
                              {proposal.yes_votes + proposal.no_votes} voters)
                            </span>
                            <span className="flex items-center gap-1">
                              <Clock className="w-3 h-3" />
                              {new Date(proposal.created_at).toLocaleDateString()}
                            </span>
                          </div>
                          <span
                            className={`flex items-center gap-1 ${timeRemaining.expired ? "text-red-500" : "text-primary"}`}
                          >
                            <Timer className="w-4 h-4" />
                            {timeRemaining.text}
                          </span>
                        </div>
                      </div>

                      {isExpired && validity && !validity.isValid && (
                        <div className="p-3 bg-red-500/10 border border-red-500/20 rounded-lg">
                          <p className="text-sm font-medium text-red-500 mb-1">Proposal Invalid:</p>
                          <ul className="text-xs text-red-400 list-disc list-inside space-y-0.5">
                            {validity.reasons.map((reason, idx) => (
                              <li key={idx}>{reason}</li>
                            ))}
                          </ul>
                        </div>
                      )}

                      {isExpired && validity && validity.isValid && (
                        <div className="p-3 bg-green-500/10 border border-green-500/20 rounded-lg">
                          <p className="text-sm font-medium text-green-500 flex items-center gap-1">
                            <CheckCircle className="w-4 h-4" />
                            Proposal Valid
                          </p>
                          <p className="text-xs text-green-400 mt-1">
                            {validity.totalVoters} voters • {validity.winningPercentage.toFixed(1)}% majority
                          </p>
                        </div>
                      )}

                      {!isExpired && isConnected && (
                        <div className="space-y-2">
                          {hasVoted ? (
                            <div className="flex items-center gap-2 text-sm text-muted-foreground">
                              <CheckCircle className="w-4 h-4 text-green-500" />
                              You have already voted on this proposal
                            </div>
                          ) : !isEligible ? (
                            <div className="flex items-center gap-2 text-sm text-muted-foreground">
                              <XCircle className="w-4 h-4 text-red-500" />
                              You need at least 100,000 tokens to vote
                            </div>
                          ) : (
                            <div className="flex gap-2">
                              <Button
                                onClick={() => handleVote(proposal.id, "yes", proposal.token_address)}
                                disabled={isVoting}
                                className="flex-1 bg-green-600 hover:bg-green-700"
                              >
                                {isVoting ? (
                                  <Loader2 className="w-4 h-4 animate-spin" />
                                ) : (
                                  <>
                                    <ThumbsUp className="w-4 h-4 mr-2" />
                                    Vote Yes
                                  </>
                                )}
                              </Button>
                              <Button
                                onClick={() => handleVote(proposal.id, "no", proposal.token_address)}
                                disabled={isVoting}
                                className="flex-1 bg-red-600 hover:bg-red-700"
                              >
                                {isVoting ? (
                                  <Loader2 className="w-4 h-4 animate-spin" />
                                ) : (
                                  <>
                                    <ThumbsDown className="w-4 h-4 mr-2" />
                                    Vote No
                                  </>
                                )}
                              </Button>
                            </div>
                          )}
                        </div>
                      )}

                      {!isConnected && !isExpired && (
                        <p className="text-sm text-muted-foreground text-center">Connect wallet to vote</p>
                      )}
                    </CardContent>
                  </Card>
                )
              })}
            </div>
          )}
        </div>
      </main>
    </div>
  )
}
[V0_FILE]json:file="components.json"
{
  "$schema": "https://ui.shadcn.com/schema.json",
  "style": "new-york",
  "rsc": true,
  "tsx": true,
  "tailwind": {
    "config": "",
    "css": "app/globals.css",
    "baseColor": "neutral",
    "cssVariables": true,
    "prefix": ""
  },
  "aliases": {
    "components": "@/components",
    "utils": "@/lib/utils",
    "ui": "@/components/ui",
    "lib": "@/lib",
    "hooks": "@/hooks"
  },
  "iconLibrary": "lucide"
}
[V0_FILE]typescriptreact:file="components/bonding-curve-chart.tsx"
"use client"

import { LineChart, Line, XAxis, YAxis, CartesianGrid, Tooltip, ResponsiveContainer } from "recharts"
import type { mockTokens } from "@/lib/mock-data"

interface BondingCurveChartProps {
  token: (typeof mockTokens)[0]
}

export default function BondingCurveChart({ token }: BondingCurveChartProps) {
  // Generate bonding curve data
  const generateCurveData = () => {
    const data = []
    const maxSupply = token.maxSupply
    const startPrice = token.startPrice

    for (let i = 0; i <= 100; i += 5) {
      const supply = (maxSupply * i) / 100
      // Simple bonding curve: price increases with supply
      const price = startPrice * Math.pow(1 + i / 100, 2)
      const marketCap = supply * price

      data.push({
        supply: (supply / 1000000).toFixed(1),
        price: price.toFixed(8),
        marketCap: (marketCap / 1000000).toFixed(2),
        percentage: i,
      })
    }

    return data
  }

  const data = generateCurveData()

  return (
    <ResponsiveContainer width="100%" height={300}>
      <LineChart data={data}>
        <CartesianGrid strokeDasharray="3 3" stroke="rgba(255,255,255,0.1)" />
        <XAxis dataKey="supply" stroke="rgba(255,255,255,0.5)" style={{ fontSize: "12px" }} />
        <YAxis stroke="rgba(255,255,255,0.5)" style={{ fontSize: "12px" }} tickFormatter={(value) => `$${value}`} />
        <Tooltip
          contentStyle={{
            backgroundColor: "rgba(20, 20, 30, 0.9)",
            border: "1px solid rgba(255,255,255,0.1)",
            borderRadius: "8px",
          }}
          formatter={(value) => `$${value}`}
          labelFormatter={(label) => `Supply: ${label}M`}
        />
        <Line
          type="monotone"
          dataKey="price"
          stroke="url(#colorGradient)"
          dot={false}
          strokeWidth={2}
          isAnimationActive={false}
        />
        <defs>
          <linearGradient id="colorGradient" x1="0" y1="0" x2="0" y2="1">
            <stop offset="5%" stopColor="rgb(153, 102, 255)" />
            <stop offset="95%" stopColor="rgb(255, 193, 7)" />
          </linearGradient>
        </defs>
      </LineChart>
    </ResponsiveContainer>
  )
}
[V0_FILE]typescriptreact:file="components/bonding-curve-view.tsx"
"use client"

import { useState, useEffect } from "react"
import { Card } from "@/components/ui/card"
import { Button } from "@/components/ui/button"
import { ArrowLeft, ExternalLink, Lock, AlertTriangle } from "lucide-react"
import BondingCurveChart from "@/components/bonding-curve-chart"
import TradePanel from "@/components/trade-panel"
import { fetchAllTokens } from "@/lib/tokens"
import type { MemeToken } from "@/lib/tokens"
import type { mockTokens } from "@/lib/mock-data"
import { formatLargeNumber } from "@/lib/utils"
import TokenComments from "@/components/token-comments"
import TokenHolders from "@/components/token-holders"
import { isTokenUnlocked } from "@/lib/contract-functions"
import { HexagonalRating } from "@/components/hexagonal-rating"

interface BondingCurveViewProps {
  token: (typeof mockTokens)[0]
  onBack: () => void
}

export default function BondingCurveView({ token: initialToken, onBack }: BondingCurveViewProps) {
  const [tradeMode, setTradeMode] = useState<"buy" | "sell">("buy")
  const [token, setToken] = useState<MemeToken>(initialToken)
  const [isUnlocked, setIsUnlocked] = useState(false)
  const [isCheckingLock, setIsCheckingLock] = useState(true)

  const handleTradeComplete = async () => {
    try {
      const tokens = await fetchAllTokens()
      const updatedToken = tokens.find((t) => t.contractAddress === token.contractAddress)

      if (updatedToken) {
        setToken(updatedToken)
      }
    } catch (error) {
      console.error("Failed to refresh token data:", error)
    }
  }

  useEffect(() => {
    setToken(initialToken)
  }, [initialToken])

  useEffect(() => {
    const checkLockStatus = async () => {
      if (token.contractAddress && token.contractAddress !== "0x0000000000000000000000000000000000000000") {
        try {
          setIsCheckingLock(true)
          const unlocked = await isTokenUnlocked(token.contractAddress)
          setIsUnlocked(unlocked)
        } catch (error) {
          console.error("Failed to check lock status:", error)
          setIsUnlocked(false)
        } finally {
          setIsCheckingLock(false)
        }
      } else {
        setIsCheckingLock(false)
      }
    }

    checkLockStatus()
  }, [token.contractAddress])

  return (
    <div className="container mx-auto px-4 py-8">
      <Button variant="ghost" onClick={onBack} className="mb-6 text-muted-foreground hover:text-foreground">
        <ArrowLeft className="w-4 h-4 mr-2" />
        Back to Tokens
      </Button>

      {!isCheckingLock && !isUnlocked && !token.isCompleted && (
        <Card className="bg-orange-500/10 border-orange-500/50 border-2 p-4 mb-6">
          <div className="flex items-center gap-3">
            <div className="p-2 bg-orange-500/20 rounded-full">
              <Lock className="w-6 h-6 text-orange-500" />
            </div>
            <div className="flex-1">
              <div className="flex items-center gap-2 mb-1">
                <AlertTriangle className="w-5 h-5 text-orange-500" />
                <h3 className="font-bold text-orange-500 text-lg">Token Locked</h3>
              </div>
              <p className="text-foreground">Creator must buy 2% (20M tokens) to unlock trading for all users.</p>
            </div>
          </div>
        </Card>
      )}

      <div className="grid grid-cols-1 lg:grid-cols-3 gap-6">
        <div className="lg:col-span-2 space-y-6">
          <Card className="bg-card border-border p-6">
            <div className="flex items-start justify-between mb-6">
              <div className="flex items-center gap-4">
                <img
                  src={token.image || "/placeholder.svg"}
                  alt={token.name}
                  className="w-16 h-16 rounded-lg object-cover"
                />
                <div>
                  <h1 className="text-3xl font-bold text-foreground">{token.name}</h1>
                  <p className="text-lg text-muted-foreground">${token.symbol}</p>
                </div>
              </div>
              {token.isAlpha && (
                <div className="px-4 py-2 rounded-lg bg-accent/20 text-accent font-semibold">✨ Alpha</div>
              )}
            </div>

            <div className="grid grid-cols-2 md:grid-cols-3 gap-4">
              <div>
                <p className="text-sm text-muted-foreground mb-1">Current Price</p>
                <p className="text-xl font-bold text-foreground">${token.currentPrice.toFixed(8)}</p>
              </div>
              <div>
                <p className="text-sm text-muted-foreground mb-1">Trust Stock Value</p>
                <p className="text-xl font-bold text-foreground">{token.marketCap.toFixed(2)} TRUST</p>
              </div>
              <div>
                <p className="text-sm text-muted-foreground mb-1">Max Supply</p>
                <p className="text-xl font-bold text-foreground">{formatLargeNumber(token.maxSupply)}</p>
              </div>
            </div>
          </Card>

          <Card className="bg-card border-border p-6">
            <h2 className="text-xl font-bold text-foreground mb-4">Bonding Curve Progress</h2>
            <BondingCurveChart token={token} />
          </Card>

          <Card className="bg-card border-border p-6">
            <h2 className="text-xl font-bold text-foreground mb-4">Creator Information</h2>
            <div className="space-y-4">
              <div>
                <p className="text-sm text-muted-foreground mb-1">Creator Address</p>
                <p className="font-mono text-sm text-foreground break-all">{token.creator}</p>
              </div>
              {token.intuitionLink && (
                <div>
                  <p className="text-sm text-muted-foreground mb-2">Intuition Graph Portal</p>
                  <a
                    href={token.intuitionLink}
                    target="_blank"
                    rel="noopener noreferrer"
                    className="inline-flex items-center gap-2 text-primary hover:text-primary/80 transition-colors"
                  >
                    View on Intuition
                    <ExternalLink className="w-4 h-4" />
                  </a>
                </div>
              )}
            </div>
          </Card>

          <TokenHolders tokenAddress={token.contractAddress} maxSupply={token.maxSupply} />

          <TokenComments tokenAddress={token.contractAddress} />
        </div>

        <div>
          <TradePanel token={token} onTradeComplete={handleTradeComplete} />
          <div className="mt-6">
            <HexagonalRating token={token} />
          </div>
        </div>
      </div>
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/create-token-modal.tsx"
"use client"

import type React from "react"

import { useState, useRef } from "react"
import { Card } from "@/components/ui/card"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { X, Upload, Loader2 } from "lucide-react"
import Image from "next/image"
import { useContract } from "@/hooks/use-contract"
import { useWallet } from "@/hooks/use-wallet"
import { checkLinkExists, createTokenInDatabase, validateIntuitionLink, normalizeIntuitionLink } from "@/lib/tokens"
import type { MemeToken } from "@/lib/tokens"

interface CreateTokenModalProps {
  onClose: () => void
  onCreate: (token: MemeToken) => void
  existingTokens?: MemeToken[]
}

export default function CreateTokenModal({ onClose, onCreate, existingTokens = [] }: CreateTokenModalProps) {
  const [step, setStep] = useState(1)
  const fileInputRef = useRef<HTMLInputElement>(null)
  const [isLoading, setIsLoading] = useState(false)
  const [error, setError] = useState("")
  const { createToken } = useContract()
  const { address } = useWallet()

  const [formData, setFormData] = useState({
    name: "",
    symbol: "",
    maxSupply: "1000000000",
    image: "/meme-token.jpg",
    intuitionLink: "",
  })

  const supplyOptions = [{ value: "1000000000", label: "1 Billion", startPrice: 0.000000001 }]

  const handleInputChange = (e: React.ChangeEvent<HTMLInputElement>) => {
    const { name, value } = e.target
    setFormData((prev) => ({ ...prev, [name]: value }))
  }

  const handleImageUpload = (e: React.ChangeEvent<HTMLInputElement>) => {
    const file = e.target.files?.[0]
    if (file) {
      const reader = new FileReader()
      reader.onloadend = () => {
        setFormData((prev) => ({ ...prev, image: reader.result as string }))
      }
      reader.readAsDataURL(file)
    }
  }

  const validateIntuitionLinkField = (): string | null => {
    const link = formData.intuitionLink.trim()

    if (link === "") {
      return null // Link is optional
    }

    const validation = validateIntuitionLink(link)
    if (!validation.valid) {
      return validation.error || "Invalid link format"
    }

    return null
  }

  const handleCreate = async () => {
    if (!address) {
      setError("Please connect your wallet first")
      return
    }

    if (!formData.name || !formData.symbol) {
      setError("Please fill in all required fields")
      return
    }

    const linkValidationError = validateIntuitionLinkField()
    if (linkValidationError) {
      setError(linkValidationError)
      return
    }

    if (formData.intuitionLink) {
      const validation = validateIntuitionLink(formData.intuitionLink)
      if (!validation.valid) {
        setError(validation.error || "Invalid link format")
        return
      }

      const linkExists = await checkLinkExists(formData.intuitionLink)
      if (linkExists) {
        setError("This Intuition Graph link is already in use. Please use a unique link.")
        return
      }
    }

    setIsLoading(true)
    setError("")

    try {
      const imageUrl = formData.image

      const metadata = JSON.stringify({
        name: formData.name,
        symbol: formData.symbol,
        intuitionLink: formData.intuitionLink,
      })

      console.log("[v0] Creating token on blockchain...")
      const tokenAddress = await createToken(formData.name, formData.symbol, metadata)
      console.log("[v0] Token created on blockchain:", tokenAddress)

      if (!tokenAddress) {
        throw new Error("Failed to create token on blockchain")
      }

      const normalizedLink = formData.intuitionLink ? normalizeIntuitionLink(formData.intuitionLink) : ""

      const newToken: Omit<MemeToken, "id"> = {
        name: formData.name,
        symbol: formData.symbol,
        image: imageUrl,
        currentPrice: 0.0001533,
        startPrice: 0.0001533,
        marketCap: 0,
        maxSupply: 1000000000,
        currentSupply: 0,
        holders: 1,
        creator: address,
        intuitionLink: normalizedLink,
        isAlpha: true,
        contractAddress: tokenAddress,
        isCompleted: false,
        createdAt: new Date().toISOString(),
      }

      console.log("[v0] Saving token to database...")
      const savedToken = await createTokenInDatabase(newToken)

      if (savedToken) {
        console.log("[v0] Token saved successfully:", savedToken.id)
        onCreate(savedToken)
        onClose()
      } else {
        console.error("[v0] createTokenInDatabase returned null")
        setError("Failed to save token to database. Please try again or contact support.")
      }
    } catch (err) {
      setError(err instanceof Error ? err.message : "Failed to create token")
      console.error("[v0] Token creation error:", err)
    } finally {
      setIsLoading(false)
    }
  }

  return (
    <div className="fixed inset-0 bg-black/50 backdrop-blur-sm flex items-center justify-center z-50 p-4">
      <Card className="bg-card border-border w-full max-w-2xl max-h-[90vh] overflow-y-auto">
        <div className="p-6 border-b border-border flex items-center justify-between sticky top-0 bg-card">
          <h2 className="text-2xl font-bold text-foreground">Create Meme Token</h2>
          <button onClick={onClose} className="text-muted-foreground hover:text-foreground transition-colors">
            <X className="w-6 h-6" />
          </button>
        </div>

        <div className="p-6 space-y-6">
          {/* Step Indicator */}
          <div className="flex gap-2">
            {[1, 2, 3].map((s) => (
              <div
                key={s}
                className={`flex-1 h-2 rounded-full transition-colors ${s <= step ? "bg-primary" : "bg-muted/30"}`}
              />
            ))}
          </div>

          {error && (
            <div className="p-3 bg-red-500/10 border border-red-500/30 rounded-lg text-sm text-red-400">{error}</div>
          )}

          {step === 1 && (
            <div className="space-y-4">
              <h3 className="text-lg font-semibold text-foreground">Basic Information</h3>

              <div>
                <label className="text-sm text-muted-foreground mb-2 block">Token Name</label>
                <Input
                  name="name"
                  placeholder="e.g., Doge Moon"
                  value={formData.name}
                  onChange={handleInputChange}
                  className="bg-input border-border text-foreground"
                />
              </div>

              <div>
                <label className="text-sm text-muted-foreground mb-2 block">Token Symbol</label>
                <Input
                  name="symbol"
                  placeholder="e.g., DMOON"
                  value={formData.symbol}
                  onChange={handleInputChange}
                  className="bg-input border-border text-foreground"
                  maxLength={10}
                />
              </div>

              <div>
                <label className="text-sm text-muted-foreground mb-2 block">Token Image</label>
                <input
                  ref={fileInputRef}
                  type="file"
                  accept="image/*"
                  onChange={handleImageUpload}
                  className="hidden"
                />
                <div
                  onClick={() => fileInputRef.current?.click()}
                  className="border-2 border-dashed border-border rounded-lg p-6 text-center hover:border-primary/50 transition-colors cursor-pointer"
                >
                  {formData.image && formData.image.startsWith("data:") ? (
                    <div className="space-y-2">
                      <div className="relative w-20 h-20 mx-auto">
                        <Image
                          src={formData.image || "/placeholder.svg"}
                          alt="Preview"
                          fill
                          className="object-cover rounded"
                        />
                      </div>
                      <p className="text-sm text-primary font-medium">Image uploaded</p>
                      <p className="text-xs text-muted-foreground">Click to change</p>
                    </div>
                  ) : (
                    <>
                      <Upload className="w-8 h-8 text-muted-foreground mx-auto mb-2" />
                      <p className="text-sm text-muted-foreground">Click to upload or drag and drop</p>
                      <p className="text-xs text-muted-foreground mt-1">PNG, JPG up to 5MB</p>
                    </>
                  )}
                </div>
              </div>
            </div>
          )}

          {step === 2 && (
            <div className="space-y-4">
              <h3 className="text-lg font-semibold text-foreground">Max Supply & Pricing</h3>

              <div>
                <label className="text-sm text-muted-foreground mb-3 block">Max Supply</label>
                <div className="p-4 rounded-lg border-2 border-primary bg-primary/10">
                  <p className="font-semibold text-foreground">1 Billion</p>
                </div>
              </div>
            </div>
          )}

          {step === 3 && (
            <div className="space-y-4">
              <h3 className="text-lg font-semibold text-foreground">Intuition Graph Link</h3>

              <div>
                <label className="text-sm text-muted-foreground mb-2 block">Intuition Portal Link (Optional)</label>
                <Input
                  name="intuitionLink"
                  placeholder="https://portal.intuition.systems/explore/atom/0x..."
                  value={formData.intuitionLink}
                  onChange={handleInputChange}
                  className="bg-input border-border text-foreground"
                />
                <p className="text-xs text-muted-foreground mt-2">
                  Link must be in the exact format: https://portal.intuition.systems/explore/atom/0x... (without any
                  additional paths or parameters). Each token must have a unique atom link.
                </p>
              </div>

              <div className="p-4 bg-muted/20 rounded-lg space-y-2">
                <p className="text-sm font-semibold text-foreground">Review Your Token:</p>
                <div className="text-sm text-muted-foreground space-y-1">
                  <p>
                    Name: <span className="text-foreground font-semibold">{formData.name}</span>
                  </p>
                  <p>
                    Symbol: <span className="text-foreground font-semibold">${formData.symbol}</span>
                  </p>
                  <p>
                    Max Supply: <span className="text-foreground font-semibold">1 Billion</span>
                  </p>
                </div>
              </div>
            </div>
          )}

          {/* Navigation Buttons */}
          <div className="flex gap-3 pt-4">
            {step > 1 && (
              <Button onClick={() => setStep(step - 1)} variant="outline" className="flex-1" disabled={isLoading}>
                Back
              </Button>
            )}
            {step < 3 ? (
              <Button
                onClick={() => setStep(step + 1)}
                className="flex-1 bg-primary hover:bg-primary/90 text-primary-foreground"
                disabled={isLoading}
              >
                Next
              </Button>
            ) : (
              <Button
                onClick={handleCreate}
                className="flex-1 bg-accent hover:bg-accent/90 text-accent-foreground disabled:opacity-50"
                disabled={isLoading}
              >
                {isLoading ? (
                  <>
                    <Loader2 className="w-4 h-4 mr-2 animate-spin" />
                    Creating...
                  </>
                ) : (
                  "Create Token"
                )}
              </Button>
            )}
          </div>
        </div>
      </Card>
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/edit-profile-modal.tsx"
"use client"

import type React from "react"

import { useState, useEffect } from "react"
import { Dialog, DialogContent, DialogHeader, DialogTitle } from "@/components/ui/dialog"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { Label } from "@/components/ui/label"
import { Upload, Loader2 } from "lucide-react"
import { createOrUpdateUserProfile, getUserProfile, type UserProfile } from "@/lib/user-profiles"
import Image from "next/image"

interface EditProfileModalProps {
  open: boolean
  onOpenChange: (open: boolean) => void
  walletAddress: string
  onProfileUpdated?: () => void
}

export default function EditProfileModal({
  open,
  onOpenChange,
  walletAddress,
  onProfileUpdated,
}: EditProfileModalProps) {
  const [displayName, setDisplayName] = useState("")
  const [profileImage, setProfileImage] = useState("")
  const [imagePreview, setImagePreview] = useState("")
  const [isLoading, setIsLoading] = useState(false)
  const [isSaving, setIsSaving] = useState(false)

  useEffect(() => {
    if (open && walletAddress) {
      loadProfile()
    }
  }, [open, walletAddress])

  const loadProfile = async () => {
    setIsLoading(true)
    try {
      const profile = await getUserProfile(walletAddress)
      if (profile) {
        setDisplayName(profile.display_name || "")
        setProfileImage(profile.profile_image || "")
        setImagePreview(profile.profile_image || "")
      }
    } catch (error) {
      console.error("[v0] Error loading profile:", error)
    } finally {
      setIsLoading(false)
    }
  }

  const handleImageChange = (e: React.ChangeEvent<HTMLInputElement>) => {
    const file = e.target.files?.[0]
    if (file) {
      const reader = new FileReader()
      reader.onloadend = () => {
        const result = reader.result as string
        setImagePreview(result)
        setProfileImage(result)
      }
      reader.readAsDataURL(file)
    }
  }

  const handleSave = async () => {
    if (!displayName.trim()) {
      alert("Please enter a display name")
      return
    }

    setIsSaving(true)
    try {
      const profileData: UserProfile = {
        wallet_address: walletAddress,
        display_name: displayName.trim(),
        profile_image: profileImage,
      }

      await createOrUpdateUserProfile(profileData)
      onProfileUpdated?.()
      onOpenChange(false)
    } catch (error) {
      console.error("[v0] Error saving profile:", error)
      alert("Failed to save profile. Please try again.")
    } finally {
      setIsSaving(false)
    }
  }

  return (
    <Dialog open={open} onOpenChange={onOpenChange}>
      <DialogContent className="sm:max-w-md">
        <DialogHeader>
          <DialogTitle>Edit Profile</DialogTitle>
        </DialogHeader>

        {isLoading ? (
          <div className="flex items-center justify-center py-8">
            <Loader2 className="w-6 h-6 animate-spin text-primary" />
          </div>
        ) : (
          <div className="space-y-4">
            {/* Profile Image */}
            <div className="space-y-2">
              <Label>Profile Image</Label>
              <div className="flex items-center gap-4">
                <div className="relative w-20 h-20 rounded-full border-2 border-border overflow-hidden bg-muted">
                  {imagePreview ? (
                    <Image src={imagePreview || "/placeholder.svg"} alt="Profile" fill className="object-cover" />
                  ) : (
                    <div className="w-full h-full flex items-center justify-center text-muted-foreground">
                      <Upload className="w-8 h-8" />
                    </div>
                  )}
                </div>
                <div className="flex-1">
                  <input
                    type="file"
                    id="profile-image"
                    accept="image/*"
                    className="hidden"
                    onChange={handleImageChange}
                  />
                  <Button
                    type="button"
                    variant="outline"
                    size="sm"
                    onClick={() => document.getElementById("profile-image")?.click()}
                  >
                    <Upload className="w-4 h-4 mr-2" />
                    Upload Image
                  </Button>
                </div>
              </div>
            </div>

            {/* Display Name */}
            <div className="space-y-2">
              <Label htmlFor="display-name">Display Name</Label>
              <Input
                id="display-name"
                value={displayName}
                onChange={(e) => setDisplayName(e.target.value)}
                placeholder="Enter your display name"
                maxLength={50}
              />
            </div>

            {/* Action Buttons */}
            <div className="flex gap-2 pt-4">
              <Button
                variant="outline"
                className="flex-1 bg-transparent"
                onClick={() => onOpenChange(false)}
                disabled={isSaving}
              >
                Cancel
              </Button>
              <Button className="flex-1" onClick={handleSave} disabled={isSaving}>
                {isSaving ? (
                  <>
                    <Loader2 className="w-4 h-4 mr-2 animate-spin" />
                    Saving...
                  </>
                ) : (
                  "Save Profile"
                )}
              </Button>
            </div>
          </div>
        )}
      </DialogContent>
    </Dialog>
  )
}
[V0_FILE]typescriptreact:file="components/footer.tsx"
import { Twitter } from "lucide-react"

export default function Footer() {
  return (
    <footer className="w-full border-t border-border bg-card mt-16">
      <div className="container mx-auto px-4 py-6">
        <div className="flex items-center justify-between">
          <div className="text-sm text-muted-foreground">© 2025 Tribe Meme</div>

          <a
            href="https://x.com/Tribememe"
            target="_blank"
            rel="noopener noreferrer"
            className="flex items-center gap-2 text-muted-foreground hover:text-primary transition-colors"
          >
            <Twitter className="w-5 h-5" />
            <span className="text-sm">Follow us on Twitter</span>
          </a>
        </div>
      </div>
    </footer>
  )
}
[V0_FILE]typescriptreact:file="components/header-profile.tsx"
"use client"

import { useEffect, useState } from "react"
import { useWallet } from "@/hooks/use-wallet"
import { getUserProfile } from "@/lib/user-profiles"
import type { UserProfile } from "@/lib/user-profiles"
import Image from "next/image"
import { User } from "lucide-react"

export default function HeaderProfile() {
  const { address } = useWallet()
  const [profile, setProfile] = useState<UserProfile | null>(null)
  const [isLoading, setIsLoading] = useState(false)

  useEffect(() => {
    const loadProfile = async () => {
      if (!address) {
        setProfile(null)
        return
      }

      if (isLoading) return

      setIsLoading(true)
      try {
        const userProfile = await getUserProfile(address)
        setProfile(userProfile)
      } catch (error) {
        console.error("[v0] Error loading user profile:", error)
        setProfile(null)
      } finally {
        setIsLoading(false)
      }
    }

    loadProfile()
  }, [address])

  if (!address) return null

  const formatAddress = (addr: string) => `${addr.slice(0, 6)}...${addr.slice(-4)}`

  return (
    <div className="flex items-center gap-3 px-3 py-2 rounded-lg bg-muted/30">
      <div className="relative w-8 h-8 rounded-full overflow-hidden bg-muted/50 flex-shrink-0">
        {profile?.profile_image ? (
          <Image src={profile.profile_image || "/placeholder.svg"} alt="Profile" fill className="object-cover" />
        ) : (
          <div className="w-full h-full flex items-center justify-center">
            <User className="w-5 h-5 text-muted-foreground" />
          </div>
        )}
      </div>
      <span className="text-sm font-mono text-foreground">{formatAddress(address)}</span>
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/header.tsx"
"use client"

import { Button } from "@/components/ui/button"
import Image from "next/image"
import { useState } from "react"
import { useWallet } from "@/hooks/use-wallet"
import { useRouter } from "next/navigation"
import HeaderProfile from "@/components/header-profile"
import { isAdmin } from "@/lib/admin-config"
import EditProfileModal from "@/components/edit-profile-modal"

interface HeaderProps {
  onCreateClick: () => void
  onAlphaClick?: () => void
}

const MenuIcon = () => (
  <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
    <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M4 6h16M4 12h16M4 18h16" />
  </svg>
)

const LogOutIcon = () => (
  <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
    <path
      strokeLinecap="round"
      strokeLinejoin="round"
      strokeWidth={2}
      d="M17 16l4-4m0 0l-4-4m4 4H7m6 4v1a3 3 0 01-3 3H6a3 3 0 01-3-3V7a3 3 0 013-3h4a3 3 0 013 3v1"
    />
  </svg>
)

const WalletIcon = () => (
  <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
    <path
      strokeLinecap="round"
      strokeLinejoin="round"
      strokeWidth={2}
      d="M3 10h18M7 15h1m4 0h1m-7 4h12a3 3 0 003-3V8a3 3 0 00-3-3H6a3 3 0 00-3 3v8a3 3 0 003 3z"
    />
  </svg>
)

const SparklesIcon = () => (
  <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
    <path
      strokeLinecap="round"
      strokeLinejoin="round"
      strokeWidth={2}
      d="M5 3v4M3 5h4M6 17v4m-2-2h4m5-16l2.286 6.857L21 12l-5.714 2.143L13 21l-2.286-6.857L5 12l5.714-2.143L13 3z"
    />
  </svg>
)

const TrendingUpIcon = () => (
  <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
    <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M13 7h8m0 0v8m0-8l-8 8-4-4-6 6" />
  </svg>
)

const PlusIcon = () => (
  <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
    <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 4v16m8-8H4" />
  </svg>
)

const ShieldIcon = () => (
  <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
    <path
      strokeLinecap="round"
      strokeLinejoin="round"
      strokeWidth={2}
      d="M9 12l2 2 4-4m5.618-4.016A11.955 11.955 0 0112 2.944a11.955 11.955 0 01-8.618 3.04A12.02 12.02 0 003 9c0 5.591 3.824 10.29 9 11.622 5.176-1.332 9-6.03 9-11.622 0-1.042-.133-2.052-.382-3.016z"
    />
  </svg>
)

const UserIcon = () => (
  <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
    <path
      strokeLinecap="round"
      strokeLinejoin="round"
      strokeWidth={2}
      d="M16 7a4 4 0 11-8 0 4 4 0 018 0zM12 14a7 7 0 00-7 7h14a7 7 0 00-7-7z"
    />
  </svg>
)

const AlertTriangleIcon = () => (
  <svg className="w-4 h-4 flex-shrink-0" fill="none" stroke="currentColor" viewBox="0 0 24 24">
    <path
      strokeLinecap="round"
      strokeLinejoin="round"
      strokeWidth={2}
      d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z"
    />
  </svg>
)

const XIcon = () => (
  <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
    <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M6 18L18 6M6 6l12 12" />
  </svg>
)

export default function Header({ onCreateClick, onAlphaClick }: HeaderProps) {
  const [showMenu, setShowMenu] = useState(false)
  const [showProfileModal, setShowProfileModal] = useState(false)
  const [showDisclaimer, setShowDisclaimer] = useState(true)
  const { address, balance, isConnecting, connect, disconnect } = useWallet()
  const router = useRouter()
  const hasAlphaAccess = Number(balance) >= 2000
  const userIsAdmin = isAdmin(address)

  const handleConnect = async () => {
    await connect()
  }

  const handleDisconnect = async () => {
    await disconnect()
    setShowMenu(false)
  }

  const formatAddress = (addr: string) => {
    return `${addr.slice(0, 6)}...${addr.slice(-6)}`
  }

  return (
    <>
      <div className="fixed top-0 left-0 md:left-16 right-0 z-50">
        {showDisclaimer && (
          <div className="absolute top-0 left-0 right-0 bg-yellow-500/90 text-black px-2 md:px-4 py-1 flex items-center justify-center gap-2 md:gap-3 z-[60]">
            <AlertTriangleIcon />
            <p className="text-[10px] md:text-xs font-medium text-center">
              Disclaimer: This app runs on non-audited smart contracts.
            </p>
            <button
              onClick={() => setShowDisclaimer(false)}
              className="absolute right-2 md:right-4 p-0.5 hover:bg-yellow-600/50 rounded transition-colors"
              aria-label="Dismiss disclaimer"
            >
              <XIcon />
            </button>
          </div>
        )}

        <header className="h-[50px] md:h-[70px] border-b border-border bg-black">
          <div className="h-full flex items-center justify-between px-2 md:px-4">
            <div className="flex items-center gap-2 md:gap-4">
              <div className="relative w-20 md:w-36 h-8 md:h-12 cursor-pointer" onClick={() => router.push("/")}>
                <Image src="/tribe-logo.png" alt="TRIBE Logo" fill className="object-contain" priority />
              </div>
              <div className="hidden lg:block h-8 w-px bg-border" />
              <Button
                onClick={onCreateClick}
                className="flex items-center gap-1 md:gap-2 bg-gradient-to-r from-primary to-primary/80 hover:from-primary/90 hover:to-primary/70 text-primary-foreground font-semibold px-2 md:px-4 text-[10px] md:text-xs h-7 md:h-8"
              >
                <PlusIcon />
                <span className="hidden sm:inline">Create Token</span>
                <span className="sm:hidden">Create</span>
              </Button>
            </div>

            <div className="flex items-center gap-2 md:gap-3">
              {address && <HeaderProfile />}

              {address && hasAlphaAccess && (
                <Button
                  onClick={onAlphaClick}
                  className="hidden md:flex bg-gradient-to-r from-primary to-primary/70 hover:from-primary/90 hover:to-primary/60 text-primary-foreground font-semibold text-xs h-8 relative overflow-hidden group"
                >
                  <div className="absolute inset-0 bg-gradient-to-r from-transparent via-white/20 to-transparent animate-pulse" />
                  <SparklesIcon />
                  <span className="ml-2">Alpha Room</span>
                </Button>
              )}

              {!address ? (
                <Button
                  onClick={handleConnect}
                  disabled={isConnecting}
                  className="bg-primary hover:bg-primary/90 text-primary-foreground font-semibold px-2 md:px-4 text-[10px] md:text-xs h-7 md:h-8"
                >
                  <WalletIcon />
                  <span className="ml-1 md:ml-2">
                    {isConnecting ? "..." : <span className="hidden sm:inline">Connect Wallet</span>}
                  </span>
                  <span className="sm:hidden ml-1">{isConnecting ? "..." : "Connect"}</span>
                </Button>
              ) : (
                <div className="relative">
                  <Button
                    variant="outline"
                    size="icon"
                    onClick={() => setShowMenu(!showMenu)}
                    className="border-border hover:bg-muted/50 h-7 w-7 md:h-8 md:w-8"
                  >
                    <MenuIcon />
                  </Button>

                  {showMenu && (
                    <div className="absolute right-0 mt-2 w-44 md:w-48 bg-card border border-border rounded-lg shadow-lg z-[100]">
                      <div className="p-2 md:p-3 border-b border-border">
                        <div className="flex items-center gap-2 px-2 md:px-3 py-1.5 md:py-2 rounded bg-muted/30">
                          <WalletIcon />
                          <span className="text-xs md:text-sm font-mono text-foreground">{formatAddress(address)}</span>
                        </div>
                      </div>
                      <div className="py-1">
                        <button
                          onClick={() => {
                            setShowProfileModal(true)
                            setShowMenu(false)
                          }}
                          className="w-full px-3 md:px-4 py-1.5 md:py-2 text-left text-xs md:text-sm text-foreground hover:bg-muted/50 flex items-center gap-2 transition-colors"
                        >
                          <UserIcon />
                          Profile
                        </button>
                        <button
                          onClick={() => {
                            router.push("/portfolio")
                            setShowMenu(false)
                          }}
                          className="w-full px-3 md:px-4 py-1.5 md:py-2 text-left text-xs md:text-sm text-foreground hover:bg-muted/50 flex items-center gap-2 transition-colors"
                        >
                          <TrendingUpIcon />
                          Portfolio
                        </button>
                        {userIsAdmin && (
                          <button
                            onClick={() => {
                              router.push("/admin")
                              setShowMenu(false)
                            }}
                            className="w-full px-3 md:px-4 py-1.5 md:py-2 text-left text-xs md:text-sm text-foreground hover:bg-muted/50 flex items-center gap-2 transition-colors"
                          >
                            <ShieldIcon />
                            Admin
                          </button>
                        )}
                      </div>
                      <div className="border-t border-border py-1">
                        <button
                          onClick={handleDisconnect}
                          className="w-full px-3 md:px-4 py-1.5 md:py-2 text-left text-xs md:text-sm text-red-400 hover:bg-muted/50 flex items-center gap-2 transition-colors"
                        >
                          <LogOutIcon />
                          Disconnect
                        </button>
                      </div>
                    </div>
                  )}
                </div>
              )}
            </div>
          </div>
        </header>
      </div>

      {address && (
        <EditProfileModal
          open={showProfileModal}
          onOpenChange={setShowProfileModal}
          walletAddress={address}
          onProfileUpdated={() => {
            window.location.reload()
          }}
        />
      )}
    </>
  )
}
[V0_FILE]typescriptreact:file="components/hexagonal-rating.tsx"
"use client"

import { useEffect, useState } from "react"
import type { MemeToken } from "@/lib/tokens"

interface HexagonalRatingProps {
  token: MemeToken
}

interface RatingMetrics {
  liquidity: number
  buy: number
  dex: number
  popularity: number
  sell: number
  rep: number
}

export function HexagonalRating({ token }: HexagonalRatingProps) {
  const [metrics, setMetrics] = useState<RatingMetrics>({
    liquidity: 0,
    buy: 0,
    dex: 0,
    popularity: 0,
    sell: 0,
    rep: 0,
  })

  useEffect(() => {
    // Calculate dynamic metrics based on token data
    const calculateMetrics = async () => {
      const maxSupply = token.maxSupply || 1000000000
      const currentSupply = token.currentSupply || 0
      const marketCap = token.marketCap || 0
      const holdersCount = token.holders && token.holders > 0 ? token.holders : 1
      const hasIntuitionLink = !!token.intuitionLink && token.intuitionLink.trim() !== ""

      // Estimate comments based on holders - more holders = more likely to have comments
      const commentsCount = Math.min(20, Math.floor(holdersCount / 2))

      // Liquidity: Based on market cap (0-100)
      const liquidity = Math.min(100, Math.max(0, marketCap > 0 ? Math.min(100, marketCap / 100 + 10) : 10))

      const supplyBoughtRatio = (currentSupply / maxSupply) * 100
      const buy = Math.min(100, Math.max(0, supplyBoughtRatio * 1.2))

      const dexThreshold = 800000000 // 800M tokens for DEX migration
      const dex = Math.min(100, Math.max(0, (currentSupply / dexThreshold) * 100))

      // Each holder adds 5 points (max 50), each comment adds 2.5 points (max 50)
      const holderPoints = Math.min(50, holdersCount * 5)
      const commentPoints = Math.min(50, commentsCount * 2.5)
      // Add minimum baseline of 5% for any existing token
      const popularity = Math.min(100, Math.max(5, holderPoints + commentPoints))

      const availableToSell = currentSupply > 0 ? (currentSupply / maxSupply) * 100 : 0
      const sell = Math.min(100, Math.max(0, availableToSell))

      // Max reputation when token has intuition link AND creator has bought 20% of token
      let rep = 0

      // Intuition link gives 50 points base
      if (hasIntuitionLink) {
        rep += 50
      }

      // Creator holdings: 20% of total supply (200M tokens) = 50 points max
      const creatorHoldingsEstimate = Math.min(currentSupply, maxSupply * 0.2)
      const creatorHoldingsRatio = (creatorHoldingsEstimate / (maxSupply * 0.2)) * 50
      rep += Math.min(50, creatorHoldingsRatio)

      rep = Math.min(100, Math.max(0, rep))

      setMetrics({
        liquidity: Math.round(liquidity),
        buy: Math.round(buy),
        dex: Math.round(dex),
        popularity: Math.round(popularity),
        sell: Math.round(sell),
        rep: Math.round(rep),
      })
    }

    calculateMetrics()
  }, [token])

  const size = 75
  const centerX = 170
  const centerY = 130
  const maxRadius = size

  // Calculate points for hexagon at given radius
  const getHexagonPoints = (radius: number) => {
    const points = []
    for (let i = 0; i < 6; i++) {
      const angle = (Math.PI / 3) * i - Math.PI / 2
      const x = centerX + radius * Math.cos(angle)
      const y = centerY + radius * Math.sin(angle)
      points.push(`${x},${y}`)
    }
    return points.join(" ")
  }

  // Calculate points for rating polygon
  const getRatingPoints = () => {
    const values = [metrics.liquidity, metrics.rep, metrics.sell, metrics.popularity, metrics.dex, metrics.buy]
    const points = []
    for (let i = 0; i < 6; i++) {
      const angle = (Math.PI / 3) * i - Math.PI / 2
      const radius = (values[i] / 100) * maxRadius
      const x = centerX + radius * Math.cos(angle)
      const y = centerY + radius * Math.sin(angle)
      points.push(`${x},${y}`)
    }
    return points.join(" ")
  }

  const labels = [
    { name: "LIQUIDITY", x: centerX, y: centerY - maxRadius - 25 },
    { name: "REP", x: centerX + maxRadius + 40, y: centerY - maxRadius / 2 - 10 },
    { name: "SELL", x: centerX + maxRadius + 40, y: centerY + maxRadius / 2 + 10 },
    { name: "POPULARITY", x: centerX, y: centerY + maxRadius + 40 },
    { name: "DEX", x: centerX - maxRadius - 40, y: centerY + maxRadius / 2 + 10 },
    { name: "BUY", x: centerX - maxRadius - 40, y: centerY - maxRadius / 2 - 10 },
  ]

  const metricValues = [metrics.liquidity, metrics.rep, metrics.sell, metrics.popularity, metrics.dex, metrics.buy]

  return (
    <div className="border border-border rounded-lg p-4">
      <svg viewBox="0 0 340 280" className="w-full max-w-[300px] mx-auto">
        {/* Background hexagon grid */}
        <polygon
          points={getHexagonPoints(maxRadius)}
          fill="none"
          stroke="rgb(234, 179, 8)"
          strokeWidth="2"
          opacity="0.6"
        />
        <polygon
          points={getHexagonPoints(maxRadius * 0.66)}
          fill="none"
          stroke="rgba(255, 255, 255, 0.2)"
          strokeWidth="1"
        />
        <polygon
          points={getHexagonPoints(maxRadius * 0.33)}
          fill="none"
          stroke="rgba(255, 255, 255, 0.1)"
          strokeWidth="1"
        />

        {/* Lines from center to vertices */}
        {[0, 1, 2, 3, 4, 5].map((i) => {
          const angle = (Math.PI / 3) * i - Math.PI / 2
          const x = centerX + maxRadius * Math.cos(angle)
          const y = centerY + maxRadius * Math.sin(angle)
          return (
            <line key={i} x1={centerX} y1={centerY} x2={x} y2={y} stroke="rgba(255, 255, 255, 0.1)" strokeWidth="1" />
          )
        })}

        {/* Rating polygon */}
        <polygon points={getRatingPoints()} fill="rgba(255, 255, 255, 0.15)" stroke="white" strokeWidth="2" />

        {labels.map((label, i) => (
          <g key={label.name}>
            <text
              x={label.x}
              y={label.y}
              textAnchor={i === 0 || i === 3 ? "middle" : i < 3 ? "start" : "end"}
              fill="rgb(234, 179, 8)"
              fontSize="14"
              fontWeight="800"
              className="uppercase"
            >
              {label.name}
            </text>
            <text
              x={label.x}
              y={label.y + 14}
              textAnchor={i === 0 || i === 3 ? "middle" : i < 3 ? "start" : "end"}
              fill="white"
              fontSize="12"
              fontWeight="700"
            >
              {metricValues[i]}%
            </text>
          </g>
        ))}
      </svg>

      {/* Legend */}
      <div className="mt-3 grid grid-cols-2 gap-1 text-[10px] text-muted-foreground">
        <div className="flex items-center gap-1">
          <div className="w-2 h-2 rounded-full bg-yellow-500" />
          <span>Max Rating</span>
        </div>
        <div className="flex items-center gap-1">
          <div className="w-2 h-2 rounded-full bg-white" />
          <span>Current Rating</span>
        </div>
      </div>
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/quick-trade-modal.tsx"
"use client"

import { useState, useEffect } from "react"
import { Card } from "@/components/ui/card"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { X, Loader2, Lock } from "lucide-react"
import { useContract } from "@/hooks/use-contract"
import { useWallet } from "@/hooks/use-wallet"
import { updateTokenInDatabase } from "@/lib/tokens"
import { getTokenInfoWithRetry, getCurrentPrice, isTokenUnlocked } from "@/lib/contract-functions"
import type { mockTokens } from "@/lib/mock-data"

interface QuickTradeModalProps {
  token: (typeof mockTokens)[0]
  onClose: () => void
  initialMode?: "buy" | "sell"
  onTradeComplete?: () => void
}

export default function QuickTradeModal({
  token,
  onClose,
  initialMode = "buy",
  onTradeComplete,
}: QuickTradeModalProps) {
  const [mode, setMode] = useState<"buy" | "sell">(initialMode)
  const [amount, setAmount] = useState("")
  const [trustAmount, setTrustAmount] = useState("")
  const [isLoading, setIsLoading] = useState(false)
  const [error, setError] = useState("")
  const { buyTokens, sellTokens } = useContract()
  const { address } = useWallet()
  const [isUnlocked, setIsUnlocked] = useState(false)
  const [isCheckingLock, setIsCheckingLock] = useState(true)

  useEffect(() => {
    const checkUnlockStatus = async () => {
      if (token.contractAddress && token.contractAddress !== "0x0000000000000000000000000000000000000000") {
        try {
          setIsCheckingLock(true)
          const unlocked = await isTokenUnlocked(token.contractAddress)
          setIsUnlocked(unlocked)
        } catch (error) {
          console.error("Failed to check unlock status:", error)
          setIsUnlocked(false)
        } finally {
          setIsCheckingLock(false)
        }
      } else {
        setIsCheckingLock(false)
      }
    }
    checkUnlockStatus()
  }, [token.contractAddress])

  const handleAmountChange = (value: string) => {
    setAmount(value)
    if (value) {
      const trust = Number.parseFloat(value) * token.currentPrice
      setTrustAmount(trust.toString())
    } else {
      setTrustAmount("")
    }
  }

  const handleTrustChange = (value: string) => {
    setTrustAmount(value)
    if (value) {
      const tokens = Number.parseFloat(value) / token.currentPrice
      setAmount(tokens.toString())
    } else {
      setAmount("")
    }
  }

  const handleTrade = async () => {
    if (!address) {
      setError("Please connect your wallet first")
      return
    }

    if (token.isCompleted) {
      setError("Trading is disabled - Token launch has been completed")
      return
    }

    if (!amount || Number.parseFloat(amount) <= 0) {
      setError("Please enter a valid amount")
      return
    }

    if (!trustAmount || Number.parseFloat(trustAmount) <= 0) {
      setError("Invalid TRUST amount. Please check your input.")
      return
    }

    setIsLoading(true)
    setError("")

    try {
      if (mode === "buy") {
        const minTokensOut = (Number.parseFloat(amount) * 0.98).toFixed(6)
        console.log("[v0] Quick trade - Buying tokens:", {
          contractAddress: token.contractAddress,
          trustAmount,
          amount,
          minTokensOut,
        })
        await buyTokens(token.contractAddress, trustAmount, minTokensOut)
      } else {
        await sellTokens(token.contractAddress, amount)
      }

      if (token.contractAddress) {
        try {
          console.log("[v0] Attempting to fetch updated token info...")
          const tokenInfo = await getTokenInfoWithRetry(token.contractAddress)
          const currentPrice = await getCurrentPrice(token.contractAddress)

          if (tokenInfo && currentPrice) {
            console.log("[v0] Updating token with:", {
              currentPrice: Number.parseFloat(currentPrice),
              currentSupply: Number.parseFloat(tokenInfo.currentSupply),
              isCompleted: tokenInfo.completed,
            })

            await updateTokenInDatabase(token.contractAddress, {
              currentPrice: Number.parseFloat(currentPrice),
              currentSupply: Number.parseFloat(tokenInfo.currentSupply),
              isCompleted: tokenInfo.completed,
            })

            console.log("[v0] Token data updated successfully")

            if (onTradeComplete) {
              onTradeComplete()
            }
          } else {
            console.log("[v0] Token data not ready yet, will update on next page load")
          }
        } catch (updateError) {
          console.log("[v0] Token data update skipped - blockchain state not ready yet")
        }
      }

      setAmount("")
      setTrustAmount("")
      setTimeout(onClose, 1000)
    } catch (err) {
      setError(err instanceof Error ? err.message : `Failed to ${mode} tokens`)
      console.error(`[v0] ${mode} error:`, err)
    } finally {
      setIsLoading(false)
    }
  }

  return (
    <div className="fixed inset-0 bg-black/50 backdrop-blur-sm flex items-center justify-center z-50 p-4">
      <Card className="bg-card border-border w-full max-w-md">
        <div className="p-6 border-b border-border flex items-center justify-between">
          <h2 className="text-xl font-bold text-foreground">Trade {token.symbol}</h2>
          <button onClick={onClose} className="text-muted-foreground hover:text-foreground transition-colors">
            <X className="w-5 h-5" />
          </button>
        </div>

        <div className="p-6 space-y-4">
          {isCheckingLock && (
            <div className="p-3 bg-muted/30 border border-border rounded-lg flex items-center gap-2">
              <Loader2 className="w-4 h-4 text-muted-foreground animate-spin flex-shrink-0" />
              <p className="text-sm text-muted-foreground">Checking token status...</p>
            </div>
          )}

          {!isCheckingLock && !isUnlocked && !token.isCompleted && (
            <div className="p-4 bg-orange-500/20 border-2 border-orange-500 rounded-lg">
              <div className="flex items-center gap-3">
                <Lock className="w-6 h-6 text-orange-500 flex-shrink-0" />
                <div>
                  <p className="text-base text-orange-500 font-bold">Token Locked</p>
                  <p className="text-sm text-orange-400 mt-1">
                    Creator must buy 2% (20M tokens) to unlock trading for other users
                  </p>
                </div>
              </div>
            </div>
          )}

          {token.isCompleted && (
            <div className="p-3 bg-orange-500/10 border border-orange-500/30 rounded-lg">
              <p className="text-sm text-orange-600 font-medium text-center">
                Trading Disabled - Token Launch Completed
              </p>
            </div>
          )}

          {/* Mode Toggle */}
          <div className="grid grid-cols-2 gap-2 bg-muted/30 p-1 rounded-lg">
            <Button
              onClick={() => setMode("buy")}
              variant={mode === "buy" ? "default" : "ghost"}
              className={mode === "buy" ? "bg-primary text-primary-foreground" : "text-muted-foreground"}
              disabled={isLoading || token.isCompleted || isCheckingLock || !isUnlocked}
            >
              Buy
            </Button>
            <Button
              onClick={() => setMode("sell")}
              variant={mode === "sell" ? "default" : "ghost"}
              className={mode === "sell" ? "bg-yellow-500 hover:bg-yellow-600 text-black" : "text-muted-foreground"}
              disabled={isLoading || token.isCompleted || isCheckingLock || !isUnlocked}
            >
              Sell
            </Button>
          </div>

          {error && (
            <div className="p-3 bg-red-500/10 border border-red-500/30 rounded-lg text-sm text-red-400">{error}</div>
          )}

          {/* Input Fields */}
          <div className="space-y-4">
            <div>
              <label className="text-sm text-muted-foreground mb-2 block">Amount ({token.symbol})</label>
              <Input
                type="number"
                placeholder="0.00"
                value={amount}
                onChange={(e) => handleAmountChange(e.target.value)}
                className="bg-input border-border text-foreground"
                disabled={isLoading || token.isCompleted || isCheckingLock || !isUnlocked}
              />
            </div>

            <div>
              <label className="text-sm text-muted-foreground mb-2 block">Cost (TRUST)</label>
              <Input
                type="number"
                placeholder="0.00"
                value={trustAmount}
                onChange={(e) => handleTrustChange(e.target.value)}
                className="bg-input border-border text-foreground"
                disabled={isLoading || token.isCompleted || isCheckingLock || !isUnlocked}
              />
            </div>
          </div>

          {/* Price Info */}
          <div className="space-y-2 p-3 bg-muted/20 rounded-lg text-sm">
            <div className="flex justify-between">
              <span className="text-muted-foreground">Price per token</span>
              <span className="text-foreground font-semibold">${token.currentPrice.toFixed(8)}</span>
            </div>
            <div className="flex justify-between">
              <span className="text-muted-foreground">Slippage</span>
              <span className="text-foreground font-semibold">2%</span>
            </div>
          </div>

          {/* Action Button */}
          <Button
            onClick={handleTrade}
            disabled={isLoading || !address || token.isCompleted || isCheckingLock || !isUnlocked}
            className={`w-full font-semibold py-5 disabled:opacity-50 ${
              mode === "buy"
                ? "bg-primary hover:bg-primary/90 text-primary-foreground"
                : "bg-yellow-500 hover:bg-yellow-600 text-black"
            }`}
          >
            {isLoading ? (
              <>
                <Loader2 className="w-4 h-4 mr-2 animate-spin" />
                {mode === "buy" ? "Buying..." : "Selling..."}
              </>
            ) : (
              `${mode === "buy" ? "Buy" : "Sell"} ${token.symbol}`
            )}
          </Button>

          <p className="text-xs text-muted-foreground text-center">
            {!address
              ? "Connect wallet to trade"
              : token.isCompleted
                ? "Token launch completed - trading disabled"
                : mode === "buy"
                  ? "Price increases as you buy"
                  : "Price decreases as you sell"}
          </p>
        </div>
      </Card>
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/sidebar.tsx"
"use client"

import type React from "react"

import { createContext, useContext } from "react"
import { Home, Trophy, BookOpen, HelpCircle, ArrowLeftRight, Vote } from "lucide-react"
import { useRouter, usePathname } from "next/navigation"
import { cn } from "@/lib/utils"
import Image from "next/image"

interface SidebarContextType {
  isCollapsed: boolean
  setIsCollapsed: (value: boolean) => void
}

const SidebarContext = createContext<SidebarContextType>({
  isCollapsed: false,
  setIsCollapsed: () => {},
})

export function useSidebar() {
  return useContext(SidebarContext)
}

export function SidebarProvider({ children }: { children: React.ReactNode }) {
  return (
    <SidebarContext.Provider value={{ isCollapsed: true, setIsCollapsed: () => {} }}>
      {children}
    </SidebarContext.Provider>
  )
}

export function Sidebar() {
  const router = useRouter()
  const pathname = usePathname()

  const navItems = [
    { icon: Home, label: "Home", path: "/", external: false },
    { icon: ArrowLeftRight, label: "DEX", path: "https://trustswap.intuition.box/home", external: true },
    { icon: Vote, label: "Vote", path: "/vote", external: false },
    { icon: Trophy, label: "Leaderboard", path: "/leaderboard", external: false },
    { icon: BookOpen, label: "Docs", path: "https://tribe-documentation.vercel.app/", external: true },
    { icon: HelpCircle, label: "FAQ", path: "/faq", external: false },
  ]

  return (
    <aside className="fixed left-0 top-0 h-screen w-16 bg-card border-r border-border z-40 hidden md:flex flex-col">
      {/* Logo section - hidden in icon-only mode */}
      <div className="h-[120px] flex items-center justify-center border-b border-border">
        <Image src="/tribe-logo.png" alt="TRIBE" width={32} height={32} className="object-contain" />
      </div>

      <nav className="flex-1 pt-4 pb-4">
        <ul className="space-y-2 px-2">
          {navItems.map((item) => {
            const Icon = item.icon
            const isActive = pathname === item.path

            return (
              <li key={item.path}>
                {item.external ? (
                  <a
                    href={item.path}
                    target="_blank"
                    rel="noopener noreferrer"
                    className={cn(
                      "w-full flex items-center justify-center p-3 rounded-lg transition-all duration-300 relative group",
                      "bg-transparent text-muted-foreground hover:bg-primary/10 hover:text-primary",
                    )}
                    title={item.label}
                  >
                    <Icon className="w-5 h-5 flex-shrink-0 transition-transform duration-300 group-hover:scale-110" />

                    {/* Tooltip */}
                    <div className="absolute left-full ml-2 px-3 py-2 bg-card border border-border rounded-lg shadow-lg opacity-0 group-hover:opacity-100 pointer-events-none transition-opacity whitespace-nowrap z-50">
                      <span className="text-sm text-foreground">{item.label}</span>
                    </div>
                  </a>
                ) : (
                  <button
                    onClick={() => router.push(item.path)}
                    className={cn(
                      "w-full flex items-center justify-center p-3 rounded-lg transition-all duration-300 relative group",
                      isActive
                        ? "bg-primary text-white"
                        : "bg-transparent text-muted-foreground hover:bg-primary/10 hover:text-primary",
                    )}
                    title={item.label}
                    type="button"
                  >
                    <Icon className="w-5 h-5 flex-shrink-0 transition-transform duration-300 group-hover:scale-110" />

                    {/* Tooltip */}
                    <div className="absolute left-full ml-2 px-3 py-2 bg-card border border-border rounded-lg shadow-lg opacity-0 group-hover:opacity-100 pointer-events-none transition-opacity whitespace-nowrap z-50">
                      <span className="text-sm text-foreground">{item.label}</span>
                    </div>
                  </button>
                )}
              </li>
            )
          })}
        </ul>
      </nav>
    </aside>
  )
}

export default Sidebar
[V0_FILE]typescriptreact:file="components/theme-provider.tsx"
'use client'

import * as React from 'react'
import {
  ThemeProvider as NextThemesProvider,
  type ThemeProviderProps,
} from 'next-themes'

export function ThemeProvider({ children, ...props }: ThemeProviderProps) {
  return <NextThemesProvider {...props}>{children}</NextThemesProvider>
}
[V0_FILE]typescriptreact:file="components/token-card.tsx"
"use client"

import type React from "react"

import { useState, useEffect } from "react"
import { Card } from "@/components/ui/card"
import { Badge } from "@/components/ui/badge"
import { Button } from "@/components/ui/button"
import { ShoppingCart, TrendingDown, ExternalLink, Copy, Star, Lock, LockOpen } from "lucide-react"
import { calculateBondingCurveProgress } from "@/lib/bonding-curve"
import QuickTradeModal from "./quick-trade-modal"
import { toggleStarToken, isTokenStarred } from "@/lib/starred-tokens"
import { useWallet } from "@/hooks/use-wallet"
import type { mockTokens } from "@/lib/mock-data"
import { isTokenUnlocked } from "@/lib/contract-functions"

interface TokenCardProps {
  token: (typeof mockTokens)[0]
  onClick: () => void
  isAlpha?: boolean
  onTradeComplete?: () => void
  onStarToggle?: () => void
}

export default function TokenCard({ token, onClick, isAlpha, onTradeComplete, onStarToggle }: TokenCardProps) {
  const [showTradeModal, setShowTradeModal] = useState(false)
  const [tradeMode, setTradeMode] = useState<"buy" | "sell">("buy")
  const [copied, setCopied] = useState(false)
  const [isStarred, setIsStarred] = useState(false)
  const [isStarring, setIsStarring] = useState(false)
  const [isUnlocked, setIsUnlocked] = useState(false)
  const [isCheckingLock, setIsCheckingLock] = useState(true)
  const { address } = useWallet()

  useEffect(() => {
    if (address) {
      isTokenStarred(address, token.contractAddress).then(setIsStarred)
    }
  }, [address, token.contractAddress])

  useEffect(() => {
    const checkUnlockStatus = async () => {
      if (token.contractAddress && token.contractAddress !== "0x0000000000000000000000000000000000000000") {
        try {
          setIsCheckingLock(true)
          const unlocked = await isTokenUnlocked(token.contractAddress)
          setIsUnlocked(unlocked)
        } catch (error) {
          console.error("Failed to check unlock status:", error)
          setIsUnlocked(false)
        } finally {
          setIsCheckingLock(false)
        }
      } else {
        setIsCheckingLock(false)
      }
    }

    checkUnlockStatus()
  }, [token.contractAddress])

  const currentPrice = token.currentPrice ?? 0
  const startPrice = token.startPrice ?? 0

  const priceChange =
    startPrice && startPrice !== 0 ? (((currentPrice - startPrice) / startPrice) * 100).toFixed(2) : "0.00"

  const bondingCurveProgress = calculateBondingCurveProgress(token.currentSupply ?? 0)

  const handleBuyClick = (e: React.MouseEvent) => {
    e.stopPropagation()
    setTradeMode("buy")
    setShowTradeModal(true)
  }

  const handleSellClick = (e: React.MouseEvent) => {
    e.stopPropagation()
    setTradeMode("sell")
    setShowTradeModal(true)
  }

  const handleCopyAddress = (e: React.MouseEvent) => {
    e.stopPropagation()
    navigator.clipboard.writeText(token.contractAddress)
    setCopied(true)
    setTimeout(() => setCopied(false), 2000)
  }

  const handleIntuitionClick = (e: React.MouseEvent) => {
    e.stopPropagation()
    if (token.intuitionLink) {
      window.open(token.intuitionLink, "_blank", "noopener,noreferrer")
    }
  }

  const handleTradeComplete = () => {
    if (onTradeComplete) {
      onTradeComplete()
    }
  }

  const handleStarClick = async (e: React.MouseEvent) => {
    e.stopPropagation()

    if (!address) {
      alert("Please connect your wallet to star tokens")
      return
    }

    setIsStarring(true)
    try {
      const newStarredState = await toggleStarToken(address, token.contractAddress)
      setIsStarred(newStarredState)
      if (onStarToggle) {
        onStarToggle()
      }
    } catch (error) {
      console.error("Failed to toggle star:", error)
      alert("Failed to star/unstar token. Please try again.")
    } finally {
      setIsStarring(false)
    }
  }

  return (
    <>
      <Card
        className={`cursor-pointer hover:border-primary/50 transition-all hover:shadow-lg overflow-hidden min-w-[180px] ${
          isAlpha ? "alpha-shimmer bg-card/80 border-accent/30" : "bg-card border-border"
        } ${token.intuitionLink ? "border-white/50 shadow-[0_0_15px_rgba(255,255,255,0.3)] hover:shadow-[0_0_20px_rgba(255,255,255,0.5)] hover:border-white" : ""}`}
        onClick={onClick}
      >
        <div className="p-2 md:p-3 space-y-1 md:space-y-1.5">
          {/* Token Header */}
          <div className="flex items-center justify-between gap-1.5">
            <div className="flex items-center gap-1.5 md:gap-2 flex-1 min-w-0">
              <img
                src={token.image || "/placeholder.svg"}
                alt={token.name}
                className="w-8 h-8 md:w-10 md:h-10 rounded-full object-cover flex-shrink-0"
              />
              <div className="flex-1 min-w-0">
                <h3 className="font-bold text-xs md:text-sm text-foreground truncate">{token.name}</h3>
                <p className="text-[8px] md:text-[10px] text-muted-foreground truncate">${token.symbol}</p>
              </div>
            </div>
            <div className="flex items-center gap-0.5 flex-shrink-0">
              <Button
                variant="ghost"
                size="sm"
                onClick={handleStarClick}
                disabled={isStarring || !address}
                className={`h-5 w-5 p-0 hover:bg-muted ${isStarred ? "text-yellow-500" : "text-muted-foreground"}`}
                title={isStarred ? "Unstar token" : "Star token"}
              >
                <Star className={`w-3 h-3 ${isStarred ? "fill-current" : ""}`} />
              </Button>
              {!isCheckingLock && (
                <div
                  className={`flex items-center justify-center h-5 w-5 rounded ${
                    isUnlocked ? "bg-green-500/10 text-green-500" : "bg-red-500/10 text-red-500"
                  }`}
                  title={
                    isUnlocked ? "Token unlocked - Available for trading" : "Token locked - Creator must buy 2% first"
                  }
                >
                  {isUnlocked ? <LockOpen className="w-3 h-3" /> : <Lock className="w-3 h-3" />}
                </div>
              )}
              {isAlpha && <Badge className="bg-accent text-accent-foreground text-[6px] px-0.5 py-0">Alpha</Badge>}
              {token.isCompleted && (
                <Badge className="bg-orange-600 text-white text-[6px] whitespace-nowrap px-0.5 py-0">Done</Badge>
              )}
            </div>
          </div>

          {/* Contract Address and Portal link row */}
          <div className="flex items-center justify-between gap-1 text-[8px] md:text-[9px]">
            <div className="flex items-center gap-0.5 min-w-0 flex-1">
              <span className="text-muted-foreground">CA:</span>
              <span className="font-mono text-foreground truncate">{token.contractAddress.slice(0, 6)}...</span>
              <Button
                variant="ghost"
                size="sm"
                onClick={handleCopyAddress}
                className="h-4 w-4 p-0 hover:bg-muted flex-shrink-0"
                title="Copy address"
              >
                <Copy className={`w-2 h-2 ${copied ? "text-green-500" : ""}`} />
              </Button>
            </div>
            {token.intuitionLink && (
              <button
                onClick={handleIntuitionClick}
                className="text-primary hover:underline flex items-center gap-0.5 font-medium flex-shrink-0"
              >
                <span>Portal</span>
                <ExternalLink className="w-2 h-2" />
              </button>
            )}
          </div>

          {/* Price and Stock row */}
          <div className="flex items-center justify-between gap-1 text-[8px] md:text-[9px]">
            <div className="flex items-center gap-0.5 min-w-0">
              <span className="text-muted-foreground">Price:</span>
              <span className="font-semibold text-foreground truncate">${currentPrice.toFixed(6)}</span>
            </div>
            <div className="flex items-center gap-0.5 min-w-0">
              <span className="text-muted-foreground">Stock:</span>
              <span className="font-semibold text-foreground truncate">{(token.marketCap ?? 0).toFixed(2)}</span>
            </div>
          </div>

          {/* Bonding curve */}
          <div className="flex items-center gap-1">
            <span className="text-[8px] md:text-[9px] text-muted-foreground flex-shrink-0">Bonding:</span>
            <div className="flex-1 bg-muted/30 rounded-full h-1">
              <div
                className="bg-gradient-to-r from-primary to-accent h-1 rounded-full transition-all duration-300"
                style={{ width: `${bondingCurveProgress}%` }}
              />
            </div>
            <span className="text-[8px] md:text-[9px] font-semibold text-accent flex-shrink-0">
              {bondingCurveProgress.toFixed(0)}%
            </span>
          </div>

          {/* Buy/Sell buttons */}
          <div className="grid grid-cols-2 gap-1.5">
            <Button
              onClick={handleBuyClick}
              size="sm"
              disabled={token.isCompleted || !isUnlocked}
              className="bg-primary hover:bg-primary/90 text-primary-foreground flex items-center justify-center gap-0.5 disabled:opacity-50 text-[9px] md:text-[10px] h-5 md:h-6 px-1"
            >
              <ShoppingCart className="w-2.5 h-2.5" />
              Buy
            </Button>
            <Button
              onClick={handleSellClick}
              size="sm"
              disabled={token.isCompleted || !isUnlocked}
              className="!bg-yellow-500 hover:!bg-yellow-600 !text-black flex items-center justify-center gap-0.5 disabled:opacity-50 text-[9px] md:text-[10px] h-5 md:h-6 px-1"
            >
              <TrendingDown className="w-2.5 h-2.5" />
              Sell
            </Button>
          </div>

          {token.isCompleted && (
            <p className="text-[7px] md:text-[8px] text-center text-orange-600 font-medium truncate">
              Trading stopped - Launch completed
            </p>
          )}
        </div>
      </Card>

      {showTradeModal && (
        <QuickTradeModal
          token={token}
          onClose={() => setShowTradeModal(false)}
          initialMode={tradeMode}
          onTradeComplete={handleTradeComplete}
        />
      )}
    </>
  )
}
[V0_FILE]typescriptreact:file="components/token-comments.tsx"
"use client"

import { useState, useEffect } from "react"
import { Card } from "@/components/ui/card"
import { Button } from "@/components/ui/button"
import { Textarea } from "@/components/ui/textarea"
import { useWallet } from "@/hooks/use-wallet"
import { MessageSquare, Send } from "lucide-react"
import { awardCommentPoints } from "@/lib/points-system"
import { createBrowserClient } from "@supabase/ssr"

interface Comment {
  commenter: string
  text: string
  timestamp: number
}

interface TokenCommentsProps {
  tokenAddress: string
}

export default function TokenComments({ tokenAddress }: TokenCommentsProps) {
  const { address } = useWallet()
  const [comments, setComments] = useState<Comment[]>([])
  const [newComment, setNewComment] = useState("")
  const [isSubmitting, setIsSubmitting] = useState(false)
  const [isLoading, setIsLoading] = useState(true)

  const loadComments = async () => {
    try {
      setIsLoading(true)
      const supabase = createBrowserClient(
        process.env.NEXT_PUBLIC_SUPABASE_URL!,
        process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
      )

      const { data, error } = await supabase
        .from("token_comments")
        .select("*")
        .eq("token_address", tokenAddress.toLowerCase())
        .order("created_at", { ascending: false })

      if (error) {
        console.error("Failed to load comments from Supabase:", error)
        setComments([])
        return
      }

      const formattedComments: Comment[] = (data || []).map((c: any) => ({
        commenter: c.commenter_address || c.commenter,
        text: c.comment_text || c.text,
        timestamp: new Date(c.created_at).getTime() / 1000,
      }))

      setComments(formattedComments)
    } catch (error) {
      console.error("Failed to load comments:", error)
      setComments([])
    } finally {
      setIsLoading(false)
    }
  }

  useEffect(() => {
    loadComments()
  }, [tokenAddress])

  const handleSubmitComment = async () => {
    if (!newComment.trim() || !address) return

    try {
      setIsSubmitting(true)

      const supabase = createBrowserClient(
        process.env.NEXT_PUBLIC_SUPABASE_URL!,
        process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
      )

      const { error } = await supabase.from("token_comments").insert({
        token_address: tokenAddress.toLowerCase(),
        commenter_address: address,
        comment_text: newComment.trim(),
        created_at: new Date().toISOString(),
      })

      if (error) {
        throw new Error(error.message)
      }

      await awardCommentPoints(address)
      setNewComment("")
      // Reload comments after submission
      await loadComments()
    } catch (error: any) {
      console.error("Failed to submit comment:", error)
      alert(error.message || "Failed to submit comment")
    } finally {
      setIsSubmitting(false)
    }
  }

  const formatAddress = (addr: string) => {
    return `${addr.slice(0, 6)}...${addr.slice(-4)}`
  }

  const formatTimestamp = (timestamp: number) => {
    const date = new Date(timestamp * 1000)
    const now = new Date()
    const diffMs = now.getTime() - date.getTime()
    const diffMins = Math.floor(diffMs / 60000)
    const diffHours = Math.floor(diffMs / 3600000)
    const diffDays = Math.floor(diffMs / 86400000)

    if (diffMins < 1) return "just now"
    if (diffMins < 60) return `${diffMins}m ago`
    if (diffHours < 24) return `${diffHours}h ago`
    if (diffDays < 7) return `${diffDays}d ago`
    return date.toLocaleDateString()
  }

  return (
    <Card className="bg-card border-border p-6">
      <div className="flex items-center gap-2 mb-4">
        <MessageSquare className="w-5 h-5 text-muted-foreground" />
        <h2 className="text-xl font-bold text-foreground">Comments</h2>
        <span className="text-sm text-muted-foreground">({comments.length})</span>
      </div>

      {/* Comment Input */}
      {address ? (
        <div className="mb-6">
          <Textarea
            value={newComment}
            onChange={(e) => setNewComment(e.target.value)}
            placeholder="Share your thoughts about this token..."
            className="mb-3 min-h-[100px] resize-none"
            maxLength={500}
          />
          <div className="flex items-center justify-between">
            <span className="text-xs text-muted-foreground">{newComment.length}/500</span>
            <Button onClick={handleSubmitComment} disabled={!newComment.trim() || isSubmitting} className="gap-2">
              <Send className="w-4 h-4" />
              {isSubmitting ? "Posting..." : "Post Comment"}
            </Button>
          </div>
        </div>
      ) : (
        <div className="mb-6 p-4 bg-muted/50 rounded-lg text-center">
          <p className="text-sm text-muted-foreground">Connect your wallet to post a comment</p>
        </div>
      )}

      {/* Comments List */}
      <div className="space-y-4">
        {isLoading ? (
          <div className="text-center py-8 text-muted-foreground">Loading comments...</div>
        ) : comments.length === 0 ? (
          <div className="text-center py-8 text-muted-foreground">
            <MessageSquare className="w-12 h-12 mx-auto mb-2 opacity-50" />
            <p>No comments yet. Be the first to comment!</p>
          </div>
        ) : (
          comments.map((comment, index) => (
            <div key={index} className="border-b border-border pb-4 last:border-0 last:pb-0">
              <div className="flex items-center justify-between mb-2">
                <span className="font-mono text-sm text-primary">{formatAddress(comment.commenter)}</span>
                <span className="text-xs text-muted-foreground">{formatTimestamp(comment.timestamp)}</span>
              </div>
              <p className="text-foreground whitespace-pre-wrap break-words">{comment.text}</p>
            </div>
          ))
        )}
      </div>
    </Card>
  )
}
[V0_FILE]typescriptreact:file="components/token-filters.tsx"
"use client"

import { Sparkles, TrendingUp, Clock, Star, Users, Rewind } from "lucide-react"

export type FilterType = "all" | "rewind2025" | "tribe" | "new" | "older" | "starred"

interface TokenFiltersProps {
  activeFilter: FilterType
  onFilterChange: (filter: FilterType) => void
  starredCount?: number
}

export default function TokenFilters({ activeFilter, onFilterChange, starredCount = 0 }: TokenFiltersProps) {
  const filters = [
    {
      id: "all" as FilterType,
      label: "All Tokens",
      icon: Sparkles,
      bgClass: "bg-primary hover:bg-primary/90",
      textClass: "text-primary-foreground",
      activeBorder: "ring-2 ring-primary ring-offset-2",
    },
    {
      id: "rewind2025" as FilterType,
      label: "Re-wind 2025",
      icon: Rewind,
      bgClass: "bg-gradient-to-r from-cyan-500 to-blue-600 hover:from-cyan-600 hover:to-blue-700",
      textClass: "text-white",
      activeBorder: "ring-2 ring-cyan-500 ring-offset-2",
    },
    {
      id: "tribe" as FilterType,
      label: "Tribe-Oriented",
      icon: Users,
      bgClass: "bg-gray-300 hover:bg-gray-400",
      textClass: "text-gray-900",
      activeBorder: "ring-2 ring-gray-500 ring-offset-2",
    },
    {
      id: "new" as FilterType,
      label: "New Tokens",
      icon: TrendingUp,
      bgClass: "bg-gradient-to-r from-orange-400 to-green-500 hover:from-orange-500 hover:to-green-600",
      textClass: "text-white",
      activeBorder: "ring-2 ring-orange-500 ring-offset-2",
    },
    {
      id: "older" as FilterType,
      label: "Older Tokens",
      icon: Clock,
      bgClass: "bg-gradient-to-r from-purple-500 to-pink-500 hover:from-purple-600 hover:to-pink-600",
      textClass: "text-white",
      activeBorder: "ring-2 ring-purple-600 ring-offset-2",
    },
    {
      id: "starred" as FilterType,
      label: "Starred",
      icon: Star,
      count: starredCount,
      bgClass: "bg-yellow-200 hover:bg-yellow-300",
      textClass: "text-yellow-900",
      activeBorder: "ring-2 ring-yellow-500 ring-offset-2",
    },
  ]

  return (
    <div className="grid grid-cols-2 md:grid-cols-3 lg:grid-cols-6 gap-2 md:gap-3 w-full">
      {filters.map((filter) => {
        const Icon = filter.icon
        const isActive = activeFilter === filter.id

        return (
          <button
            key={filter.id}
            onClick={() => onFilterChange(filter.id)}
            className={`
              flex items-center justify-center gap-1.5 px-2 md:px-3 py-2 rounded-lg font-medium text-xs md:text-sm whitespace-nowrap transition-all
              ${filter.bgClass} ${filter.textClass}
              ${isActive ? filter.activeBorder : ""}
            `}
          >
            <Icon className="w-3 h-3 md:w-4 md:h-4" />
            <span className="hidden sm:inline">{filter.label}</span>
            <span className="sm:hidden">{filter.label.split(" ")[0]}</span>
            {filter.count !== undefined && filter.count > 0 && (
              <span className="text-xs px-1.5 py-0.5 rounded-full font-semibold bg-black/10">{filter.count}</span>
            )}
          </button>
        )
      })}
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/token-grid.tsx"
"use client"
import TokenCard from "@/components/token-card"
import type { mockTokens } from "@/lib/mock-data"

interface TokenGridProps {
  tokens: typeof mockTokens
  onSelectToken: (token: (typeof mockTokens)[0]) => void
  onTradeComplete?: () => void
  onStarToggle?: () => void
  onTokenHover?: (token: (typeof mockTokens)[0] | null) => void
}

export default function TokenGrid({
  tokens,
  onSelectToken,
  onTradeComplete,
  onStarToggle,
  onTokenHover,
}: TokenGridProps) {
  const tribeOrientedTokens = tokens.filter((t) => t.intuitionLink && t.intuitionLink.trim() !== "")
  const allTokens = tokens.filter((t) => !t.intuitionLink || t.intuitionLink.trim() === "")

  return (
    <div className="space-y-8 md:space-y-10">
      {tribeOrientedTokens.length > 0 && (
        <section>
          <div className="mb-3 md:mb-4">
            <h2 className="text-lg md:text-2xl font-bold text-foreground mb-0.5">Tribe-Oriented</h2>
            <p className="text-[10px] md:text-sm text-muted-foreground">Tokens with Intuition knowledge graph</p>
          </div>
          <div className="grid grid-cols-2 md:grid-cols-3 lg:grid-cols-4 gap-3 md:gap-4">
            {tribeOrientedTokens.map((token) => (
              <div key={token.id} className="alpha-glow rounded-xl" onMouseEnter={() => onTokenHover?.(token)}>
                <TokenCard
                  token={token}
                  onClick={() => onSelectToken(token)}
                  isAlpha
                  onTradeComplete={onTradeComplete}
                  onStarToggle={onStarToggle}
                />
              </div>
            ))}
          </div>
        </section>
      )}

      {allTokens.length > 0 && (
        <section>
          <div className="mb-3 md:mb-4">
            <h2 className="text-lg md:text-2xl font-bold text-foreground mb-0.5">All Tokens</h2>
            <p className="text-[10px] md:text-sm text-muted-foreground">Discover new meme tokens</p>
          </div>
          <div className="grid grid-cols-2 md:grid-cols-3 lg:grid-cols-4 gap-3 md:gap-4">
            {allTokens.map((token) => (
              <div key={token.id} className="alpha-glow rounded-xl" onMouseEnter={() => onTokenHover?.(token)}>
                <TokenCard
                  key={token.id}
                  token={token}
                  onClick={() => onSelectToken(token)}
                  onTradeComplete={onTradeComplete}
                  onStarToggle={onStarToggle}
                />
              </div>
            ))}
          </div>
        </section>
      )}
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/token-holders.tsx"
"use client"

import { useState, useEffect } from "react"
import { Card } from "@/components/ui/card"
import { Users } from "lucide-react"
import { getTokenHolderBalance } from "@/lib/contract-functions"
import { createBrowserClient } from "@/lib/supabase/client"

interface HolderInfo {
  address: string
  balance: string
  percentage: number
}

interface TokenHoldersProps {
  tokenAddress: string
  maxSupply: number
}

export default function TokenHolders({ tokenAddress, maxSupply }: TokenHoldersProps) {
  const [holders, setHolders] = useState<HolderInfo[]>([])
  const [isLoading, setIsLoading] = useState(true)

  useEffect(() => {
    const loadHolders = async () => {
      try {
        setIsLoading(true)

        const supabase = createBrowserClient()
        const { data: holdersData, error } = await supabase
          .from("token_holders")
          .select("holder_address, balance")
          .eq("token_address", tokenAddress.toLowerCase())

        if (error) {
          console.error("Failed to fetch holders:", error)
          setHolders([])
          return
        }

        // Convert to HolderInfo format
        const holderInfo = (holdersData || [])
          .map((holder) => {
            const balance = holder.balance ? Number(holder.balance).toString() : "0"
            const balanceNum = Number.parseFloat(balance)
            if (balanceNum <= 0) return null

            const percentage = (balanceNum / maxSupply) * 100

            return {
              address: holder.holder_address,
              balance,
              percentage,
            }
          })
          .filter((h): h is HolderInfo => h !== null)

        // Sort by balance descending
        holderInfo.sort((a, b) => Number.parseFloat(b.balance) - Number.parseFloat(a.balance))

        setHolders(holderInfo)
      } catch (error) {
        console.error("Failed to load holders:", error)
      } finally {
        setIsLoading(false)
      }
    }

    loadHolders()
  }, [tokenAddress, maxSupply])

  const formatAddress = (addr: string) => {
    return `${addr.slice(0, 6)}...${addr.slice(-4)}`
  }

  const formatBalance = (balance: string) => {
    const num = Number.parseFloat(balance)
    if (num >= 1000000) return `${(num / 1000000).toFixed(2)}M`
    if (num >= 1000) return `${(num / 1000).toFixed(2)}K`
    return num.toFixed(2)
  }

  return (
    <Card className="bg-card border-border p-6">
      <div className="flex items-center gap-2 mb-4">
        <Users className="w-5 h-5 text-muted-foreground" />
        <h2 className="text-xl font-bold text-foreground">Token Holders</h2>
        <span className="text-sm text-muted-foreground">({holders.length})</span>
      </div>

      {isLoading ? (
        <div className="text-center py-8 text-muted-foreground">Loading holders...</div>
      ) : holders.length === 0 ? (
        <div className="text-center py-8 text-muted-foreground">
          <Users className="w-12 h-12 mx-auto mb-2 opacity-50" />
          <p>No holders yet</p>
        </div>
      ) : (
        <div className="space-y-3">
          {holders.map((holder, index) => (
            <div key={holder.address} className="flex items-center justify-between p-3 bg-muted/50 rounded-lg">
              <div className="flex items-center gap-3">
                <span className="text-sm font-bold text-muted-foreground w-6">#{index + 1}</span>
                <div>
                  <p className="font-mono text-sm text-foreground">{formatAddress(holder.address)}</p>
                  <p className="text-xs text-muted-foreground">{formatBalance(holder.balance)} tokens</p>
                </div>
              </div>
              <div className="flex items-center gap-2">
                <div className="w-24 h-2 bg-muted rounded-full overflow-hidden">
                  <div
                    className="h-full bg-primary rounded-full"
                    style={{ width: `${Math.min(holder.percentage, 100)}%` }}
                  />
                </div>
                <span className="text-sm font-bold text-foreground w-16 text-right">
                  {holder.percentage.toFixed(2)}%
                </span>
              </div>
            </div>
          ))}
        </div>
      )}
    </Card>
  )
}
[V0_FILE]typescriptreact:file="components/trade-panel.tsx"
"use client"

import { useState, useEffect } from "react"
import { Card } from "@/components/ui/card"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { Loader2 } from "lucide-react"
import { useContract } from "@/hooks/use-contract"
import { useWallet } from "@/hooks/use-wallet"
import { getUserTokenBalance } from "@/lib/user-holdings"
import { updateTokenInDatabase } from "@/lib/tokens"
import { getTokenInfoWithRetry, getCurrentPrice } from "@/lib/contract-functions"
import type { mockTokens } from "@/lib/mock-data"

interface TradePanelProps {
  token: (typeof mockTokens)[0] & { factory_address?: string } // Add factory_address to token type
  onTradeComplete?: () => void // Add callback to refresh token data
}

export default function TradePanel({ token, onTradeComplete }: TradePanelProps) {
  const [mode, setMode] = useState<"buy" | "sell">("buy")
  const [amount, setAmount] = useState("")
  const [trustAmount, setTrustAmount] = useState("")
  const [payoutAddress, setPayoutAddress] = useState("")
  const [isLoading, setIsLoading] = useState(false)
  const [error, setError] = useState("")
  const [userBalance, setUserBalance] = useState("0")
  const [trustBalance, setTrustBalance] = useState("0") // Added state for user's TRUST balance
  const { buyTokens, sellTokens } = useContract()
  const { address } = useWallet()

  useEffect(() => {
    const fetchBalance = async () => {
      if (address && token.contractAddress) {
        const balance = await getUserTokenBalance(token.contractAddress, address)
        setUserBalance(balance)
      } else {
        setUserBalance("0")
      }
    }

    fetchBalance()
  }, [address, token.contractAddress])

  useEffect(() => {
    const fetchTrustBalance = async () => {
      if (address && typeof window !== "undefined" && window.ethereum) {
        try {
          const { BrowserProvider, formatEther } = await import("ethers")
          const provider = new BrowserProvider(window.ethereum)
          const balance = await provider.getBalance(address)
          setTrustBalance(formatEther(balance))
        } catch (error) {
          console.error("Failed to fetch TRUST balance:", error)
          setTrustBalance("0")
        }
      } else {
        setTrustBalance("0")
      }
    }

    fetchTrustBalance()

    // Refresh balance every 10 seconds
    const interval = setInterval(fetchTrustBalance, 10000)
    return () => clearInterval(interval)
  }, [address])

  const handleAmountChange = (value: string) => {
    setAmount(value)
    if (value) {
      const currentPrice = token.currentPrice || 0.0001533
      const trust = Number.parseFloat(value) * currentPrice
      setTrustAmount(trust.toFixed(6))
    } else {
      setTrustAmount("")
    }
  }

  const handleTrustChange = (value: string) => {
    setTrustAmount(value)
    if (value) {
      const currentPrice = token.currentPrice || 0.0001533
      const tokens = Number.parseFloat(value) / currentPrice
      setAmount(tokens.toFixed(6))
    } else {
      setAmount("")
    }
  }

  const handleTrade = async () => {
    if (!address) {
      setError("Please connect your wallet first")
      return
    }

    if (token.isCompleted) {
      setError("Trading is disabled - Token launch has been completed")
      return
    }

    if (!amount || Number.parseFloat(amount) <= 0) {
      setError("Please enter a valid amount")
      return
    }

    if (!trustAmount || Number.parseFloat(trustAmount) <= 0) {
      setError("Invalid TRUST amount calculated. Please check your input.")
      return
    }

    if (!token.contractAddress || token.contractAddress === "") {
      setError("Invalid token contract address")
      return
    }

    setIsLoading(true)
    setError("")

    try {
      if (mode === "buy") {
        const minTokensOut = (Number.parseFloat(amount) * 0.98).toFixed(6)
        console.log("[v0] Buying tokens:", {
          contractAddress: token.contractAddress,
          trustAmount,
          amount,
          minTokensOut,
        })
        await buyTokens(token.contractAddress, trustAmount, minTokensOut)
      } else {
        console.log("[v0] Selling tokens:", {
          contractAddress: token.contractAddress,
          amount,
          payoutAddress: payoutAddress || "Not specified (will use wallet address)",
        })
        await sellTokens(token.contractAddress, amount, token.factory_address, payoutAddress || undefined)
      }

      if (token.contractAddress) {
        const balance = await getUserTokenBalance(token.contractAddress, address)
        setUserBalance(balance)

        try {
          console.log("[v0] Attempting to fetch updated token info...")
          const tokenInfo = await getTokenInfoWithRetry(token.contractAddress)
          const currentPrice = await getCurrentPrice(token.contractAddress)

          if (tokenInfo && currentPrice) {
            console.log("[v0] Updating token with:", {
              currentPrice: Number.parseFloat(currentPrice),
              currentSupply: Number.parseFloat(tokenInfo.currentSupply),
              isCompleted: tokenInfo.completed,
            })

            await updateTokenInDatabase(token.contractAddress, {
              currentPrice: Number.parseFloat(currentPrice),
              currentSupply: Number.parseFloat(tokenInfo.currentSupply),
              isCompleted: tokenInfo.completed,
            })

            console.log("[v0] Token data updated successfully")

            if (onTradeComplete) {
              onTradeComplete()
            }
          } else {
            console.log("[v0] Token data not ready yet, will update on next page load")
          }
        } catch (updateError) {
          console.log("[v0] Token data update skipped - blockchain state not ready yet")
        }
      }

      setAmount("")
      setTrustAmount("")
      setPayoutAddress("")
    } catch (err) {
      setError(err instanceof Error ? err.message : `Failed to ${mode} tokens`)
      console.error(`[v0] ${mode} error:`, err)
    } finally {
      setIsLoading(false)
    }
  }

  const handlePercentageClick = (percentage: number) => {
    if (mode === "buy") {
      // For buying, use percentage of TRUST balance
      const trustToSpend = (Number.parseFloat(trustBalance) * percentage) / 100
      handleTrustChange(trustToSpend.toFixed(6))
    } else {
      // For selling, use percentage of token balance
      const tokensToSell = (Number.parseFloat(userBalance) * percentage) / 100
      handleAmountChange(tokensToSell.toFixed(6))
    }
  }

  return (
    <Card className="bg-card border-border p-6 sticky top-24">
      <h2 className="text-xl font-bold text-foreground mb-4">Trade</h2>

      {address && token.contractAddress && (
        <div className="mb-4 p-3 bg-muted/20 rounded-lg">
          <div className="flex justify-between items-center">
            <span className="text-sm text-muted-foreground">Your Balance</span>
            <span className="font-semibold text-foreground">
              {Number.parseFloat(userBalance).toFixed(2)} {token.symbol}
            </span>
          </div>
        </div>
      )}

      {token.isCompleted && (
        <div className="mb-4 p-3 bg-orange-500/10 border border-orange-500/30 rounded-lg">
          <p className="text-sm text-orange-600 font-medium text-center">Trading Disabled - Token Launch Completed</p>
        </div>
      )}

      <div className="grid grid-cols-2 gap-2 mb-6 bg-muted/30 p-1 rounded-lg">
        <Button
          onClick={() => setMode("buy")}
          variant={mode === "buy" ? "default" : "ghost"}
          className={mode === "buy" ? "bg-primary text-primary-foreground" : "text-muted-foreground"}
          disabled={isLoading || token.isCompleted}
        >
          Buy
        </Button>
        <Button
          onClick={() => setMode("sell")}
          variant="ghost"
          className={
            mode === "sell" ? "!bg-yellow-500 hover:!bg-yellow-600 !text-black font-semibold" : "text-muted-foreground"
          }
          disabled={isLoading || token.isCompleted}
        >
          Sell
        </Button>
      </div>

      {error && (
        <div className="p-3 bg-red-500/10 border border-red-500/30 rounded-lg text-sm text-red-400 mb-4">{error}</div>
      )}

      <div className="space-y-4 mb-6">
        <div>
          <label className="text-sm text-muted-foreground mb-2 block">Amount ({token.symbol})</label>
          <Input
            type="number"
            placeholder="0.00"
            value={amount}
            onChange={(e) => handleAmountChange(e.target.value)}
            className="bg-input border-border text-foreground"
            disabled={isLoading || token.isCompleted}
          />
          {mode === "sell" && address && Number.parseFloat(userBalance) > 0 && (
            <div className="flex gap-2 mt-2">
              <Button
                type="button"
                variant="outline"
                size="sm"
                className="flex-1 text-xs bg-transparent"
                onClick={() => handlePercentageClick(25)}
                disabled={isLoading || token.isCompleted}
              >
                25%
              </Button>
              <Button
                type="button"
                variant="outline"
                size="sm"
                className="flex-1 text-xs bg-transparent"
                onClick={() => handlePercentageClick(50)}
                disabled={isLoading || token.isCompleted}
              >
                50%
              </Button>
              <Button
                type="button"
                variant="outline"
                size="sm"
                className="flex-1 text-xs bg-transparent"
                onClick={() => handlePercentageClick(75)}
                disabled={isLoading || token.isCompleted}
              >
                75%
              </Button>
              <Button
                type="button"
                variant="outline"
                size="sm"
                className="flex-1 text-xs bg-transparent"
                onClick={() => handlePercentageClick(100)}
                disabled={isLoading || token.isCompleted}
              >
                100%
              </Button>
            </div>
          )}
        </div>

        <div>
          <div className="flex justify-between items-center mb-2">
            <label className="text-sm text-muted-foreground">Cost (TRUST)</label>
            {address && (
              <span className="text-xs text-primary">Balance: {Number.parseFloat(trustBalance).toFixed(4)} TRUST</span>
            )}
          </div>
          <Input
            type="number"
            placeholder="0.00"
            value={trustAmount}
            onChange={(e) => handleTrustChange(e.target.value)}
            className="bg-input border-border text-foreground"
            disabled={isLoading || token.isCompleted}
          />
          {mode === "buy" && address && Number.parseFloat(trustBalance) > 0 && (
            <div className="flex gap-2 mt-2">
              <Button
                type="button"
                variant="outline"
                size="sm"
                className="flex-1 text-xs bg-transparent"
                onClick={() => handlePercentageClick(25)}
                disabled={isLoading || token.isCompleted}
              >
                25%
              </Button>
              <Button
                type="button"
                variant="outline"
                size="sm"
                className="flex-1 text-xs bg-transparent"
                onClick={() => handlePercentageClick(50)}
                disabled={isLoading || token.isCompleted}
              >
                50%
              </Button>
              <Button
                type="button"
                variant="outline"
                size="sm"
                className="flex-1 text-xs bg-transparent"
                onClick={() => handlePercentageClick(75)}
                disabled={isLoading || token.isCompleted}
              >
                75%
              </Button>
              <Button
                type="button"
                variant="outline"
                size="sm"
                className="flex-1 text-xs bg-transparent"
                onClick={() => handlePercentageClick(100)}
                disabled={isLoading || token.isCompleted}
              >
                100%
              </Button>
            </div>
          )}
        </div>

        {mode === "sell" && (
          <div>
            <label className="text-sm text-muted-foreground mb-2 block">
              Payout Address (Optional)
            </label>
            <Input
              type="text"
              placeholder="0x... (Leave empty to receive TRUST to your wallet)"
              value={payoutAddress}
              onChange={(e) => setPayoutAddress(e.target.value)}
              className="bg-input border-border text-foreground text-xs"
              disabled={isLoading || token.isCompleted}
            />
            <p className="text-xs text-muted-foreground mt-1">
              Enter a different address to receive TRUST proceeds to that address instead of your connected wallet
            </p>
          </div>
        )}
      </div>

      <div className="space-y-2 mb-6 p-4 bg-muted/20 rounded-lg">
        <div className="flex justify-between text-sm">
          <span className="text-muted-foreground">Price per token</span>
          <span className="text-foreground font-semibold">${(token.currentPrice || 0.0001533).toFixed(8)}</span>
        </div>
        <div className="flex justify-between text-sm">
          <span className="text-muted-foreground">Slippage</span>
          <span className="text-foreground font-semibold">2%</span>
        </div>
      </div>

      <Button
        onClick={handleTrade}
        disabled={isLoading || !address || token.isCompleted}
        variant="ghost"
        className={`w-full font-semibold py-6 text-lg disabled:opacity-50 ${
          mode === "buy"
            ? "!bg-primary hover:!bg-primary/90 !text-primary-foreground"
            : "!bg-yellow-500 hover:!bg-yellow-600 !text-black"
        }`}
      >
        {isLoading ? (
          <>
            <Loader2 className="w-4 h-4 mr-2 animate-spin" />
            {mode === "buy" ? "Buying..." : "Selling..."}
          </>
        ) : (
          `${mode === "buy" ? "Buy " : "Sell "} ${token.symbol}`
        )}
      </Button>

      <p className="text-xs text-muted-foreground mt-4 text-center">
        {!address
          ? "Connect wallet to trade"
          : token.isCompleted
            ? "Token launch completed - trading disabled"
            : mode === "buy"
              ? "Price increases as you buy"
              : "Price decreases as you sell"}
      </p>
    </Card>
  )
}
[V0_FILE]typescriptreact:file="components/tvt-ticker.tsx"
"use client"

import { useState, useEffect, useRef } from "react"
import { getTotalTVT, getTokenTVT, getAllTokenAddresses } from "@/lib/contract-functions"
import { Contract, JsonRpcProvider } from "ethers"
import { CONTRACT_CONFIG } from "@/lib/contract-config"
import ABI from "@/lib/contract-abi.json"

interface TokenTVT {
  symbol: string
  name: string
  tvt: string
  address: string
}

export default function TVTTicker() {
  const [totalTVT, setTotalTVT] = useState<string>("0")
  const [tokenTVTs, setTokenTVTs] = useState<TokenTVT[]>([])
  const [isLoading, setIsLoading] = useState(true)
  const cachedTokensRef = useRef<TokenTVT[]>([])
  const cachedTotalRef = useRef<string>("0")

  useEffect(() => {
    loadTVTData()
    const interval = setInterval(loadTVTData, 30000)
    return () => clearInterval(interval)
  }, [])

  const loadTVTData = async () => {
    try {
      const provider = new JsonRpcProvider(CONTRACT_CONFIG.network.rpcUrl, {
        name: CONTRACT_CONFIG.network.name,
        chainId: CONTRACT_CONFIG.chainId,
      })
      const contract = new Contract(CONTRACT_CONFIG.address, ABI, provider)

      // Get total TVT
      try {
        const total = await getTotalTVT()
        setTotalTVT(total)
        cachedTotalRef.current = total
      } catch {
        if (cachedTotalRef.current !== "0") {
          setTotalTVT(cachedTotalRef.current)
        }
      }

      try {
        const tokenAddresses = await getAllTokenAddresses()

        if (tokenAddresses && tokenAddresses.length > 0) {
          const tokenDataPromises = tokenAddresses.map(async (address: string) => {
            try {
              if (!address || address === "0x0000000000000000000000000000000000000000") {
                return null
              }

              const tokenInfo = await contract.getTokenInfo(address)
              const tvt = await getTokenTVT(address)

              return {
                symbol: tokenInfo.symbol || "???",
                name: tokenInfo.name || "Unknown",
                tvt,
                address,
              }
            } catch {
              return null
            }
          })

          const results = await Promise.all(tokenDataPromises)
          const filtered = results
            .filter((t): t is TokenTVT => t !== null && Number.parseFloat(t.tvt) > 0)
            .sort((a, b) => Number.parseFloat(b.tvt) - Number.parseFloat(a.tvt))

          cachedTokensRef.current = filtered
          setTokenTVTs(filtered)
        } else if (cachedTokensRef.current.length > 0) {
          setTokenTVTs(cachedTokensRef.current)
        }
      } catch {
        if (cachedTokensRef.current.length > 0) {
          setTokenTVTs(cachedTokensRef.current)
        }
      }
    } catch {
      if (cachedTokensRef.current.length > 0) {
        setTokenTVTs(cachedTokensRef.current)
      }
      if (cachedTotalRef.current !== "0") {
        setTotalTVT(cachedTotalRef.current)
      }
    } finally {
      setIsLoading(false)
    }
  }

  const formatTVT = (value: string) => {
    const num = Number.parseFloat(value)
    if (num >= 1000000) {
      return `${(num / 1000000).toFixed(2)}M`
    } else if (num >= 1000) {
      return `${(num / 1000).toFixed(2)}K`
    }
    return num.toFixed(4)
  }

  if (isLoading) {
    return (
      <div className="w-full bg-gradient-to-r from-primary/10 via-primary/5 to-primary/10 border-b border-primary/20">
        <div className="flex items-center h-8 px-4">
          <span className="text-xs text-primary mr-2">📈</span>
          <span className="text-xs text-muted-foreground">Loading trading data...</span>
        </div>
      </div>
    )
  }

  if (Number.parseFloat(totalTVT) === 0 && tokenTVTs.length === 0) {
    return null
  }

  return (
    <div className="w-full bg-gradient-to-r from-primary/10 via-primary/5 to-primary/10 border-b border-primary/20">
      <div className="relative h-8 overflow-hidden">
        <div className="absolute inset-0 flex items-center">
          <div className="flex items-center gap-6 px-4 animate-marquee whitespace-nowrap">
            {/* First set of content */}
            <div className="flex items-center gap-2 text-primary">
              <span className="text-xs">📈</span>
              <span className="text-xs font-semibold">TRIBE TVT</span>
            </div>

            <div className="flex items-center gap-1.5 bg-primary/20 px-2 py-0.5 rounded">
              <span className="text-xs text-muted-foreground">Total:</span>
              <span className="text-xs font-bold text-primary">{formatTVT(totalTVT)} TRUST</span>
            </div>

            {tokenTVTs.map((token, index) => (
              <div key={index} className="flex items-center gap-1.5 px-2 py-0.5 rounded bg-muted/30">
                <span className="text-xs font-medium text-foreground">${token.symbol}</span>
                <span className="text-xs text-primary font-semibold">{formatTVT(token.tvt)} TRUST</span>
              </div>
            ))}

            <span className="mx-8 text-primary/50">•</span>

            {/* Duplicate content for seamless loop */}
            <div className="flex items-center gap-2 text-primary">
              <span className="text-xs">📈</span>
              <span className="text-xs font-semibold">TRIBE TVT</span>
            </div>

            <div className="flex items-center gap-1.5 bg-primary/20 px-2 py-0.5 rounded">
              <span className="text-xs text-muted-foreground">Total:</span>
              <span className="text-xs font-bold text-primary">{formatTVT(totalTVT)} TRUST</span>
            </div>

            {tokenTVTs.map((token, index) => (
              <div key={`dup-${index}`} className="flex items-center gap-1.5 px-2 py-0.5 rounded bg-muted/30">
                <span className="text-xs font-medium text-foreground">${token.symbol}</span>
                <span className="text-xs text-primary font-semibold">{formatTVT(token.tvt)} TRUST</span>
              </div>
            ))}

            <span className="mx-8 text-primary/50">•</span>
          </div>
        </div>
      </div>
    </div>
  )
}
[V0_FILE]typescriptreact:file="components/ui/badge.tsx"
import * as React from 'react'
import { Slot } from '@radix-ui/react-slot'
import { cva, type VariantProps } from 'class-variance-authority'

import { cn } from '@/lib/utils'

const badgeVariants = cva(
  'inline-flex items-center justify-center rounded-md border px-2 py-0.5 text-xs font-medium w-fit whitespace-nowrap shrink-0 [&>svg]:size-3 gap-1 [&>svg]:pointer-events-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive transition-[color,box-shadow] overflow-hidden',
  {
    variants: {
      variant: {
        default:
          'border-transparent bg-primary text-primary-foreground [a&]:hover:bg-primary/90',
        secondary:
          'border-transparent bg-secondary text-secondary-foreground [a&]:hover:bg-secondary/90',
        destructive:
          'border-transparent bg-destructive text-white [a&]:hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/60',
        outline:
          'text-foreground [a&]:hover:bg-accent [a&]:hover:text-accent-foreground',
      },
    },
    defaultVariants: {
      variant: 'default',
    },
  },
)

function Badge({
  className,
  variant,
  asChild = false,
  ...props
}: React.ComponentProps<'span'> &
  VariantProps<typeof badgeVariants> & { asChild?: boolean }) {
  const Comp = asChild ? Slot : 'span'

  return (
    <Comp
      data-slot="badge"
      className={cn(badgeVariants({ variant }), className)}
      {...props}
    />
  )
}

export { Badge, badgeVariants }
[V0_FILE]typescriptreact:file="components/ui/button.tsx"
import * as React from 'react'
import { Slot } from '@radix-ui/react-slot'
import { cva, type VariantProps } from 'class-variance-authority'

import { cn } from '@/lib/utils'

const buttonVariants = cva(
  "inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium transition-all disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4 shrink-0 [&_svg]:shrink-0 outline-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive",
  {
    variants: {
      variant: {
        default: 'bg-primary text-primary-foreground hover:bg-primary/90',
        destructive:
          'bg-destructive text-white hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/60',
        outline:
          'border bg-background shadow-xs hover:bg-accent hover:text-accent-foreground dark:bg-input/30 dark:border-input dark:hover:bg-input/50',
        secondary:
          'bg-secondary text-secondary-foreground hover:bg-secondary/80',
        ghost:
          'hover:bg-accent hover:text-accent-foreground dark:hover:bg-accent/50',
        link: 'text-primary underline-offset-4 hover:underline',
      },
      size: {
        default: 'h-9 px-4 py-2 has-[>svg]:px-3',
        sm: 'h-8 rounded-md gap-1.5 px-3 has-[>svg]:px-2.5',
        lg: 'h-10 rounded-md px-6 has-[>svg]:px-4',
        icon: 'size-9',
        'icon-sm': 'size-8',
        'icon-lg': 'size-10',
      },
    },
    defaultVariants: {
      variant: 'default',
      size: 'default',
    },
  },
)

function Button({
  className,
  variant,
  size,
  asChild = false,
  ...props
}: React.ComponentProps<'button'> &
  VariantProps<typeof buttonVariants> & {
    asChild?: boolean
  }) {
  const Comp = asChild ? Slot : 'button'

  return (
    <Comp
      data-slot="button"
      className={cn(buttonVariants({ variant, size, className }))}
      {...props}
    />
  )
}

export { Button, buttonVariants }
[V0_FILE]typescriptreact:file="components/ui/card.tsx"
import * as React from 'react'

import { cn } from '@/lib/utils'

function Card({ className, ...props }: React.ComponentProps<'div'>) {
  return (
    <div
      data-slot="card"
      className={cn(
        'bg-card text-card-foreground flex flex-col gap-6 rounded-xl border py-6 shadow-sm',
        className,
      )}
      {...props}
    />
  )
}

function CardHeader({ className, ...props }: React.ComponentProps<'div'>) {
  return (
    <div
      data-slot="card-header"
      className={cn(
        '@container/card-header grid auto-rows-min grid-rows-[auto_auto] items-start gap-2 px-6 has-data-[slot=card-action]:grid-cols-[1fr_auto] [.border-b]:pb-6',
        className,
      )}
      {...props}
    />
  )
}

function CardTitle({ className, ...props }: React.ComponentProps<'div'>) {
  return (
    <div
      data-slot="card-title"
      className={cn('leading-none font-semibold', className)}
      {...props}
    />
  )
}

function CardDescription({ className, ...props }: React.ComponentProps<'div'>) {
  return (
    <div
      data-slot="card-description"
      className={cn('text-muted-foreground text-sm', className)}
      {...props}
    />
  )
}

function CardAction({ className, ...props }: React.ComponentProps<'div'>) {
  return (
    <div
      data-slot="card-action"
      className={cn(
        'col-start-2 row-span-2 row-start-1 self-start justify-self-end',
        className,
      )}
      {...props}
    />
  )
}

function CardContent({ className, ...props }: React.ComponentProps<'div'>) {
  return (
    <div
      data-slot="card-content"
      className={cn('px-6', className)}
      {...props}
    />
  )
}

function CardFooter({ className, ...props }: React.ComponentProps<'div'>) {
  return (
    <div
      data-slot="card-footer"
      className={cn('flex items-center px-6 [.border-t]:pt-6', className)}
      {...props}
    />
  )
}

export {
  Card,
  CardHeader,
  CardFooter,
  CardTitle,
  CardAction,
  CardDescription,
  CardContent,
}
[V0_FILE]typescriptreact:file="components/ui/dialog.tsx"
'use client'

import * as React from 'react'
import * as DialogPrimitive from '@radix-ui/react-dialog'
import { XIcon } from 'lucide-react'

import { cn } from '@/lib/utils'

function Dialog({
  ...props
}: React.ComponentProps<typeof DialogPrimitive.Root>) {
  return <DialogPrimitive.Root data-slot="dialog" {...props} />
}

function DialogTrigger({
  ...props
}: React.ComponentProps<typeof DialogPrimitive.Trigger>) {
  return <DialogPrimitive.Trigger data-slot="dialog-trigger" {...props} />
}

function DialogPortal({
  ...props
}: React.ComponentProps<typeof DialogPrimitive.Portal>) {
  return <DialogPrimitive.Portal data-slot="dialog-portal" {...props} />
}

function DialogClose({
  ...props
}: React.ComponentProps<typeof DialogPrimitive.Close>) {
  return <DialogPrimitive.Close data-slot="dialog-close" {...props} />
}

function DialogOverlay({
  className,
  ...props
}: React.ComponentProps<typeof DialogPrimitive.Overlay>) {
  return (
    <DialogPrimitive.Overlay
      data-slot="dialog-overlay"
      className={cn(
        'data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 fixed inset-0 z-50 bg-black/50',
        className,
      )}
      {...props}
    />
  )
}

function DialogContent({
  className,
  children,
  showCloseButton = true,
  ...props
}: React.ComponentProps<typeof DialogPrimitive.Content> & {
  showCloseButton?: boolean
}) {
  return (
    <DialogPortal data-slot="dialog-portal">
      <DialogOverlay />
      <DialogPrimitive.Content
        data-slot="dialog-content"
        className={cn(
          'bg-background data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 fixed top-[50%] left-[50%] z-50 grid w-full max-w-[calc(100%-2rem)] translate-x-[-50%] translate-y-[-50%] gap-4 rounded-lg border p-6 shadow-lg duration-200 sm:max-w-lg',
          className,
        )}
        {...props}
      >
        {children}
        {showCloseButton && (
          <DialogPrimitive.Close
            data-slot="dialog-close"
            className="ring-offset-background focus:ring-ring data-[state=open]:bg-accent data-[state=open]:text-muted-foreground absolute top-4 right-4 rounded-xs opacity-70 transition-opacity hover:opacity-100 focus:ring-2 focus:ring-offset-2 focus:outline-hidden disabled:pointer-events-none [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4"
          >
            <XIcon />
            <span className="sr-only">Close</span>
          </DialogPrimitive.Close>
        )}
      </DialogPrimitive.Content>
    </DialogPortal>
  )
}

function DialogHeader({ className, ...props }: React.ComponentProps<'div'>) {
  return (
    <div
      data-slot="dialog-header"
      className={cn('flex flex-col gap-2 text-center sm:text-left', className)}
      {...props}
    />
  )
}

function DialogFooter({ className, ...props }: React.ComponentProps<'div'>) {
  return (
    <div
      data-slot="dialog-footer"
      className={cn(
        'flex flex-col-reverse gap-2 sm:flex-row sm:justify-end',
        className,
      )}
      {...props}
    />
  )
}

function DialogTitle({
  className,
  ...props
}: React.ComponentProps<typeof DialogPrimitive.Title>) {
  return (
    <DialogPrimitive.Title
      data-slot="dialog-title"
      className={cn('text-lg leading-none font-semibold', className)}
      {...props}
    />
  )
}

function DialogDescription({
  className,
  ...props
}: React.ComponentProps<typeof DialogPrimitive.Description>) {
  return (
    <DialogPrimitive.Description
      data-slot="dialog-description"
      className={cn('text-muted-foreground text-sm', className)}
      {...props}
    />
  )
}

export {
  Dialog,
  DialogClose,
  DialogContent,
  DialogDescription,
  DialogFooter,
  DialogHeader,
  DialogOverlay,
  DialogPortal,
  DialogTitle,
  DialogTrigger,
}
[V0_FILE]typescriptreact:file="components/ui/input.tsx"
import * as React from 'react'

import { cn } from '@/lib/utils'

function Input({ className, type, ...props }: React.ComponentProps<'input'>) {
  return (
    <input
      type={type}
      data-slot="input"
      className={cn(
        'file:text-foreground placeholder:text-muted-foreground selection:bg-primary selection:text-primary-foreground dark:bg-input/30 border-input h-9 w-full min-w-0 rounded-md border bg-transparent px-3 py-1 text-base shadow-xs transition-[color,box-shadow] outline-none file:inline-flex file:h-7 file:border-0 file:bg-transparent file:text-sm file:font-medium disabled:pointer-events-none disabled:cursor-not-allowed disabled:opacity-50 md:text-sm',
        'focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px]',
        'aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive',
        className,
      )}
      {...props}
    />
  )
}

export { Input }
[V0_FILE]typescriptreact:file="components/ui/label.tsx"
'use client'

import * as React from 'react'
import * as LabelPrimitive from '@radix-ui/react-label'

import { cn } from '@/lib/utils'

function Label({
  className,
  ...props
}: React.ComponentProps<typeof LabelPrimitive.Root>) {
  return (
    <LabelPrimitive.Root
      data-slot="label"
      className={cn(
        'flex items-center gap-2 text-sm leading-none font-medium select-none group-data-[disabled=true]:pointer-events-none group-data-[disabled=true]:opacity-50 peer-disabled:cursor-not-allowed peer-disabled:opacity-50',
        className,
      )}
      {...props}
    />
  )
}

export { Label }
[V0_FILE]typescriptreact:file="components/ui/textarea.tsx"
import * as React from "react"

import { cn } from "@/lib/utils"

export interface TextareaProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {}

const Textarea = React.forwardRef<HTMLTextAreaElement, TextareaProps>(({ className, ...props }, ref) => {
  return (
    <textarea
      className={cn(
        "flex min-h-[80px] w-full rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50",
        className,
      )}
      ref={ref}
      {...props}
    />
  )
})
Textarea.displayName = "Textarea"

export { Textarea }
[V0_FILE]typescriptreact:file="components/user-profile-card.tsx"
"use client"

import { useEffect, useState } from "react"
import { useWallet } from "@/hooks/use-wallet"
import { getUserProfile } from "@/lib/user-profiles"
import type { UserProfile } from "@/lib/user-profiles"
import { Card } from "@/components/ui/card"
import Image from "next/image"
import { User, Settings } from "lucide-react"
import { useRouter } from "next/navigation"
import { Button } from "@/components/ui/button"

export default function UserProfileCard() {
  const { address } = useWallet()
  const [profile, setProfile] = useState<UserProfile | null>(null)
  const [isLoading, setIsLoading] = useState(false)
  const router = useRouter()

  useEffect(() => {
    const loadProfile = async () => {
      if (!address) {
        setProfile(null)
        return
      }

      setIsLoading(true)
      try {
        const userProfile = await getUserProfile(address)
        setProfile(userProfile)
      } catch (error) {
        console.error("[v0] Error loading user profile:", error)
        setProfile(null)
      } finally {
        setIsLoading(false)
      }
    }

    loadProfile()
  }, [address])

  if (!address) return null

  if (isLoading) {
    return (
      <Card className="bg-card border-border p-4">
        <div className="flex items-center gap-3">
          <div className="w-12 h-12 rounded-full bg-muted/30 animate-pulse" />
          <div className="flex-1 space-y-2">
            <div className="h-4 bg-muted/30 rounded animate-pulse w-32" />
            <div className="h-3 bg-muted/30 rounded animate-pulse w-24" />
          </div>
        </div>
      </Card>
    )
  }

  const displayName = profile?.display_name || `${address.slice(0, 6)}...${address.slice(-4)}`
  const hasProfile = profile?.display_name || profile?.profile_image || profile?.bio

  return (
    <Card className="bg-card border-border p-4 hover:border-primary/50 transition-colors">
      <div className="flex items-center gap-4">
        <div className="relative w-16 h-16 rounded-full overflow-hidden bg-muted/30 flex-shrink-0">
          {profile?.profile_image ? (
            <Image src={profile.profile_image || "/placeholder.svg"} alt={displayName} fill className="object-cover" />
          ) : (
            <div className="w-full h-full flex items-center justify-center">
              <User className="w-8 h-8 text-muted-foreground" />
            </div>
          )}
        </div>

        <div className="flex-1 min-w-0">
          <h3 className="font-semibold text-foreground truncate">{displayName}</h3>
          <p className="text-sm text-muted-foreground font-mono truncate">{`${address.slice(0, 8)}...${address.slice(-6)}`}</p>
          {profile?.bio && <p className="text-xs text-muted-foreground mt-1 line-clamp-2">{profile.bio}</p>}
        </div>

        <Button
          variant="outline"
          size="sm"
          onClick={() => router.push("/settings")}
          className="flex-shrink-0 border-border hover:bg-muted/50"
        >
          <Settings className="w-4 h-4 mr-2" />
          {hasProfile ? "Edit" : "Setup"}
        </Button>
      </div>
    </Card>
  )
}
[V0_FILE]typescriptreact:file="components/welcome-splash.tsx"
"use client"

import { useState } from "react"
import { Button } from "@/components/ui/button"
import { Card } from "@/components/ui/card"
import { ArrowRight } from "lucide-react"

interface WelcomeSplashProps {
  onEnter: () => void
}

export default function WelcomeSplash({ onEnter }: WelcomeSplashProps) {
  const [isVisible, setIsVisible] = useState(true)
  const [isExiting, setIsExiting] = useState(false)

  const handleEnter = () => {
    setIsExiting(true)
    setTimeout(() => {
      setIsVisible(false)
      onEnter()
    }, 500)
  }

  if (!isVisible) return null

  return (
    <div
      className={`fixed inset-0 z-[100] flex flex-col items-center justify-center bg-black transition-opacity duration-500 ${
        isExiting ? "opacity-0" : "opacity-100"
      }`}
    >
      <Card className="relative z-10 bg-card border border-border hover:border-primary/50 transition-all hover:shadow-lg rounded-xl max-w-md mx-4">
        <div className="p-6 md:p-8 space-y-5">
          <div className="flex items-center justify-center pb-5 border-b border-border">
            <div className="w-24 h-24 rounded-full border-2 border-border overflow-hidden">
              <img
                src="/pepe-frog-wearing-gold-chains-rapper-style-cartoon.jpg"
                alt="Pepe"
                className="w-full h-full object-cover object-top scale-150"
              />
            </div>
          </div>

          <div className="pb-5 border-b border-border">
            <p className="text-xl font-medium text-foreground text-center">Create on TRIBE. Trade Natively.</p>
          </div>

          <div className="pt-2">
            <Button
              onClick={handleEnter}
              size="lg"
              className="w-full bg-primary hover:bg-primary/90 text-primary-foreground"
            >
              Enter Launchpad
              <ArrowRight className="w-4 h-4 ml-2" />
            </Button>
          </div>
        </div>
      </Card>
    </div>
  )
}
[V0_FILE]typescript:file="hooks/use-contract.ts"
"use client"

import { useState } from "react"
import * as contractFunctions from "@/lib/contract-functions"

export function useContract() {
  const [isLoading, setIsLoading] = useState(false)
  const [error, setError] = useState<string | null>(null)

  const createToken = async (name: string, symbol: string, metadata: string) => {
    setIsLoading(true)
    setError(null)
    try {
      const tokenAddress = await contractFunctions.createToken(name, symbol, metadata)
      return tokenAddress
    } catch (err: any) {
      const errorMsg = err.message || "Failed to create token"
      setError(errorMsg)
      throw err
    } finally {
      setIsLoading(false)
    }
  }

  const buyTokens = async (tokenAddress: string, trustAmount: string, minTokensOut?: string) => {
    setIsLoading(true)
    setError(null)
    try {
      const receipt = await contractFunctions.buyTokens(tokenAddress, trustAmount, minTokensOut)
      return receipt
    } catch (err: any) {
      const errorMsg = err.message || "Failed to buy tokens"
      setError(errorMsg)
      throw err
    } finally {
      setIsLoading(false)
    }
  }

  const sellTokens = async (tokenAddress: string, tokenAmount: string, factoryAddress?: string) => {
    setIsLoading(true)
    setError(null)
    try {
      const receipt = await contractFunctions.sellTokens(tokenAddress, tokenAmount, factoryAddress)
      return receipt
    } catch (err: any) {
      const errorMsg = err.message || "Failed to sell tokens"
      setError(errorMsg)
      throw err
    } finally {
      setIsLoading(false)
    }
  }

  const getTokenInfo = async (tokenAddress: string) => {
    setIsLoading(true)
    setError(null)
    try {
      return await contractFunctions.getTokenInfo(tokenAddress)
    } catch (err: any) {
      const errorMsg = err.message || "Failed to get token info"
      setError(errorMsg)
      throw err
    } finally {
      setIsLoading(false)
    }
  }

  const getCurrentPrice = async (tokenAddress: string) => {
    setIsLoading(true)
    setError(null)
    try {
      return await contractFunctions.getCurrentPrice(tokenAddress)
    } catch (err: any) {
      const errorMsg = err.message || "Failed to get price"
      setError(errorMsg)
      throw err
    } finally {
      setIsLoading(false)
    }
  }

  return {
    isLoading,
    error,
    createToken,
    buyTokens,
    sellTokens,
    getTokenInfo,
    getCurrentPrice,
  }
}
[V0_FILE]typescript:file="hooks/use-wallet.ts"
"use client"

import { useState, useEffect, useCallback } from "react"
import { getConnectedAddress, getBalance, disconnectWallet, forceNewWalletConnection } from "@/lib/web3-provider"

export function useWallet() {
  const [address, setAddress] = useState<string | null>(null)
  const [balance, setBalance] = useState<string>("0")
  const [isConnecting, setIsConnecting] = useState(false)
  const [error, setError] = useState<string | null>(null)

  const refreshBalance = useCallback(async (addr: string) => {
    try {
      const bal = await getBalance(addr)
      setBalance(bal)
    } catch (err) {
      console.error("Failed to refresh balance:", err)
    }
  }, [])

  useEffect(() => {
    if (typeof window === "undefined" || typeof localStorage === "undefined") {
      return
    }

    // Check if already connected
    const checkConnection = async () => {
      try {
        const wasConnected = localStorage.getItem("walletConnected")

        if (!wasConnected) {
          return
        }

        const addr = await getConnectedAddress()

        if (addr) {
          setAddress(addr)
          const bal = await getBalance(addr)
          setBalance(bal)
        } else {
          localStorage.removeItem("walletConnected")
        }
      } catch (err) {
        console.error("Failed to check wallet connection:", err)
        try {
          if (typeof localStorage !== "undefined") {
            localStorage.removeItem("walletConnected")
          }
        } catch (e) {
          // Ignore localStorage errors
        }
      }
    }

    checkConnection()

    // Listen for account changes
    if (typeof window !== "undefined" && window.ethereum) {
      const handleAccountsChanged = (accounts: string[]) => {
        if (accounts.length > 0) {
          setAddress(accounts[0])
          getBalance(accounts[0]).then(setBalance)
          if (typeof localStorage !== "undefined") {
            localStorage.setItem("walletConnected", "true")
          }
        } else {
          setAddress(null)
          setBalance("0")
          if (typeof localStorage !== "undefined") {
            localStorage.removeItem("walletConnected")
          }
        }
      }

      const handleChainChanged = () => {
        // Reload the page to reset all state when chain changes
        window.location.reload()
      }

      window.ethereum.on("accountsChanged", handleAccountsChanged)
      window.ethereum.on("chainChanged", handleChainChanged)

      return () => {
        window.ethereum.removeListener("accountsChanged", handleAccountsChanged)
        window.ethereum.removeListener("chainChanged", handleChainChanged)
      }
    }
  }, [])

  const connect = async () => {
    if (isConnecting) {
      return
    }

    setIsConnecting(true)
    setError(null)

    try {
      if (typeof window === "undefined" || !window.ethereum) {
        throw new Error("MetaMask or Web3 wallet not found. Please install MetaMask.")
      }

      // Use the new forceNewWalletConnection that shows account picker
      const addr = await forceNewWalletConnection()

      setAddress(addr)
      const bal = await getBalance(addr)
      setBalance(bal)

      if (typeof localStorage !== "undefined") {
        localStorage.setItem("walletConnected", "true")
      }
    } catch (err: any) {
      const errorMessage = err.message || "Failed to connect wallet"
      setError(errorMessage)
      console.error("[v0] Wallet connection error:", err)

      if (errorMessage.includes("No Web3 wallet detected") || errorMessage.includes("not found")) {
        alert("Please install MetaMask or another Web3 wallet to connect.")
      } else if (errorMessage.includes("cancelled by user")) {
        // User cancelled, no need to alert
      } else if (!errorMessage.includes("already pending")) {
        alert(errorMessage)
      }
    } finally {
      setIsConnecting(false)
    }
  }

  const disconnect = async () => {
    try {
      // Clear state immediately
      setAddress(null)
      setBalance("0")
      setError(null)

      // Then clear backend
      await disconnectWallet()
    } catch (err) {
      console.error("Failed to disconnect wallet:", err)
    }
  }

  return {
    address,
    balance,
    isConnecting,
    error,
    connect,
    disconnect,
    isConnected: !!address,
    refreshBalance: () => address && refreshBalance(address),
  }
}
[V0_FILE]typescript:file="lib/admin-config.ts"
"use client"

/**
 * Check if a wallet address is authorized as an admin
 */
export function isAdmin(address: string | undefined): boolean {
  if (!address) return false

  // Get admin addresses from environment variable
  // Format: comma-separated list of addresses
  const adminAddresses =
    process.env.NEXT_PUBLIC_ADMIN_ADDRESSES?.split(",").map((addr) => addr.trim().toLowerCase()) || []

  // Check if the connected address is in the admin list
  return adminAddresses.includes(address.toLowerCase())
}

/**
 * Get list of admin addresses (for debugging)
 */
export function getAdminAddresses(): string[] {
  return process.env.NEXT_PUBLIC_ADMIN_ADDRESSES?.split(",").map((addr) => addr.trim()) || []
}
[V0_FILE]typescript:file="lib/bonding-curve.ts"
// Bonding curve calculation constants matching the smart contract
export const BONDING_CURVE_CONFIG = {
  INITIAL_PRICE: 0.0001533, // Initial price in TRUST per token
  MAX_SUPPLY: 1000000000, // 1 billion tokens total
  BONDING_CURVE_PERCENT: 70, // 70% of max supply (700M tokens)
  PRICE_STEP_SIZE: 100000000, // 100M tokens - step size for quadratic calculation
  CREATOR_MAX_BUY_PERCENT: 20, // Creator can buy max 20% of bonding curve (140M tokens)
  FEE_PERCENT: 1, // 1% fee on trades
}

/**
 * Calculate price based on current supply using quadratic bonding curve
 * Matches the smart contract formula: price = INITIAL_PRICE * (1 + (currentSupply / PRICE_STEP_SIZE)^2)
 * This is the pump.fun style pricing model
 */
export function calculateBondingCurvePrice(currentSupply: number): number {
  const { INITIAL_PRICE, PRICE_STEP_SIZE, MAX_SUPPLY, BONDING_CURVE_PERCENT } = BONDING_CURVE_CONFIG

  // Calculate bonding curve maximum (70% of total supply)
  const bondingMax = (MAX_SUPPLY * BONDING_CURVE_PERCENT) / 100

  // Ensure currentSupply doesn't exceed bonding curve limit
  const effectiveSupply = Math.min(currentSupply, bondingMax)

  if (effectiveSupply === 0) {
    return INITIAL_PRICE
  }

  // Quadratic bonding curve formula from the smart contract
  // supplyRatio = currentSupply / PRICE_STEP_SIZE
  const supplyRatio = effectiveSupply / PRICE_STEP_SIZE

  // price = INITIAL_PRICE * (1 + supplyRatio^2)
  const price = INITIAL_PRICE * (1 + supplyRatio * supplyRatio)

  return price
}

/**
 * Calculate the percentage of bonding curve allocation that has been filled
 * Returns 0-100 representing how much of the 700M bonding curve tokens have been bought
 */
export function calculateBondingCurveProgress(currentSupply: number): number {
  const { MAX_SUPPLY, BONDING_CURVE_PERCENT } = BONDING_CURVE_CONFIG
  const bondingCurveLimit = (MAX_SUPPLY * BONDING_CURVE_PERCENT) / 100 // 700M tokens

  // Return percentage of bonding curve filled (0-100)
  return Math.min((currentSupply / bondingCurveLimit) * 100, 100)
}

/**
 * Calculate how many tokens can be bought with a given amount of TRUST
 * Uses the current price from the bonding curve
 */
export function calculateTokensFromTrust(trustAmount: number, currentSupply: number): number {
  const currentPrice = calculateBondingCurvePrice(currentSupply)
  return trustAmount / currentPrice
}

/**
 * Calculate how much TRUST is needed to buy a given amount of tokens
 * Uses the current price from the bonding curve
 */
export function calculateTrustFromTokens(tokenAmount: number, currentSupply: number): number {
  const currentPrice = calculateBondingCurvePrice(currentSupply)
  return tokenAmount * currentPrice
}

/**
 * Calculate how much TRUST will be received when selling tokens
 * Includes the 1% fee deduction
 */
export function calculateTrustFromSell(tokenAmount: number, currentSupply: number): number {
  const currentPrice = calculateBondingCurvePrice(currentSupply)
  const grossTrust = tokenAmount * currentPrice
  const fee = (grossTrust * BONDING_CURVE_CONFIG.FEE_PERCENT) / 100
  return grossTrust - fee
}

/**
 * Calculate market cap based on current price and actual current supply
 * Market Cap = Current Price × Current Supply
 */
export function calculateMarketCap(currentSupply: number): number {
  if (currentSupply === 0) {
    return 0
  }
  
  const currentPrice = calculateBondingCurvePrice(currentSupply)
  
  // Market cap = current price × actual current supply
  return currentPrice * currentSupply
}
[V0_FILE]json:file="lib/contract-abi.json"
[
  {
    "type": "constructor",
    "inputs": [
      {
        "name": "_treasuryAddress",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "_dexRouter",
        "type": "address",
        "internalType": "address"
      }
    ],
    "stateMutability": "nonpayable"
  },
  {
    "type": "receive",
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "BONDING_CURVE_PERCENT",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "COMMENT_FEE",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "CREATOR_MAX_BUY_PERCENT",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "CREATOR_UNLOCK_THRESHOLD_PERCENT",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "HELD_PERCENT",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "INITIAL_PRICE",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "MAX_FEE_PERCENT",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "MAX_SUPPLY",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "MAX_TRANSFER_FEE_PERCENT",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "PRICE_STEP_SIZE",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "addComment",
    "inputs": [
      {
        "name": "tokenAddress",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "commentText",
        "type": "string",
        "internalType": "string"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "allTokens",
    "inputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "address",
        "internalType": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "allTokensLength",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "auditTrustAccounting",
    "inputs": [
      {
        "name": "tokenAddress",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [
      {
        "name": "accountingValid",
        "type": "bool",
        "internalType": "bool"
      },
      {
        "name": "curveLiquidityAmount",
        "type": "uint256",
        "internalType": "uint256"
      },
      {
        "name": "contractBalance",
        "type": "uint256",
        "internalType": "uint256"
      },
      {
        "name": "balanceDifference",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "buyTokens",
    "inputs": [
      {
        "name": "tokenAddress",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "minTokensOut",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "tokensBought",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "checkMigrationReadiness",
    "inputs": [
      {
        "name": "tokenAddress",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [
      {
        "name": "ready",
        "type": "bool",
        "internalType": "bool"
      },
      {
        "name": "tokenAmount",
        "type": "uint256",
        "internalType": "uint256"
      },
      {
        "name": "nativeAmount",
        "type": "uint256",
        "internalType": "uint256"
      },
      {
        "name": "tokenContractBalance",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "collectAndSplitTransferFees",
    "inputs": [
      {
        "name": "tokenAddress",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "completeTokenLaunch",
    "inputs": [
      {
        "name": "tokenAddress",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "createToken",
    "inputs": [
      {
        "name": "name",
        "type": "string",
        "internalType": "string"
      },
      {
        "name": "symbol",
        "type": "string",
        "internalType": "string"
      },
      {
        "name": "metadata",
        "type": "string",
        "internalType": "string"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "address",
        "internalType": "address"
      }
    ],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "creatorBoughtAmount",
    "inputs": [
      {
        "name": "",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "creatorTransferFeePercent",
    "inputs": [
      {
        "name": "",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "curveLiquidity",
    "inputs": [
      {
        "name": "",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "defaultPostMigrationTransferFeePercent",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "dexRouter",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "address",
        "internalType": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "emergencyWithdrawTokens",
    "inputs": [
      {
        "name": "tokenAddress",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "feePercent",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getAvailableWithdrawalAmount",
    "inputs": [
      {
        "name": "tokenAddress",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "recipient",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [
      {
        "name": "availableTokenAmount",
        "type": "uint256",
        "internalType": "uint256"
      },
      {
        "name": "availableNativeAmount",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getCurrentPrice",
    "inputs": [
      {
        "name": "tokenAddress",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getTokenInfo",
    "inputs": [
      {
        "name": "tokenAddress",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "tuple",
        "internalType": "struct MemeLaunchpad.TokenInfo",
        "components": [
          {
            "name": "name",
            "type": "string",
            "internalType": "string"
          },
          {
            "name": "symbol",
            "type": "string",
            "internalType": "string"
          },
          {
            "name": "metadata",
            "type": "string",
            "internalType": "string"
          },
          {
            "name": "creator",
            "type": "address",
            "internalType": "address"
          },
          {
            "name": "heldTokens",
            "type": "uint256",
            "internalType": "uint256"
          },
          {
            "name": "maxSupply",
            "type": "uint256",
            "internalType": "uint256"
          },
          {
            "name": "currentSupply",
            "type": "uint256",
            "internalType": "uint256"
          },
          {
            "name": "completed",
            "type": "bool",
            "internalType": "bool"
          },
          {
            "name": "creationTime",
            "type": "uint256",
            "internalType": "uint256"
          }
        ]
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "isValidToken",
    "inputs": [
      {
        "name": "",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool",
        "internalType": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "owner",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "address",
        "internalType": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "sellTokens",
    "inputs": [
      {
        "name": "tokenAddress",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "tokenAmount",
        "type": "uint256",
        "internalType": "uint256"
      },
      {
        "name": "minPaymentOut",
        "type": "uint256",
        "internalType": "uint256"
      },
      {
        "name": "payoutTo",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [
      {
        "name": "paymentReceived",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "setCreatorTransferFee",
    "inputs": [
      {
        "name": "tokenAddress",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "transferFeePercent",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "setDefaultPostMigrationTransferFeePercent",
    "inputs": [
      {
        "name": "newTransferFeePercent",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "setDexRouter",
    "inputs": [
      {
        "name": "newDexRouter",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "setFeePercent",
    "inputs": [
      {
        "name": "newFeePercent",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "tokenInfo",
    "inputs": [
      {
        "name": "",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [
      {
        "name": "name",
        "type": "string",
        "internalType": "string"
      },
      {
        "name": "symbol",
        "type": "string",
        "internalType": "string"
      },
      {
        "name": "metadata",
        "type": "string",
        "internalType": "string"
      },
      {
        "name": "creator",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "heldTokens",
        "type": "uint256",
        "internalType": "uint256"
      },
      {
        "name": "maxSupply",
        "type": "uint256",
        "internalType": "uint256"
      },
      {
        "name": "currentSupply",
        "type": "uint256",
        "internalType": "uint256"
      },
      {
        "name": "completed",
        "type": "bool",
        "internalType": "bool"
      },
      {
        "name": "creationTime",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "tokenLPToken",
    "inputs": [
      {
        "name": "",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "address",
        "internalType": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "tokenTotalValueTraded",
    "inputs": [
      {
        "name": "",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "tokenUnlocked",
    "inputs": [
      {
        "name": "",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool",
        "internalType": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "transferFeeEnabled",
    "inputs": [
      {
        "name": "",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool",
        "internalType": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "transferOwnership",
    "inputs": [
      {
        "name": "newOwner",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "treasuryAddress",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "address",
        "internalType": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "userContributions",
    "inputs": [
      {
        "name": "",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "userTokenPurchases",
    "inputs": [
      {
        "name": "",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "userVolumes",
    "inputs": [
      {
        "name": "",
        "type": "address",
        "internalType": "address"
      }
    ],
    "outputs": [
      {
        "name": "totalBuyVolume",
        "type": "uint256",
        "internalType": "uint256"
      },
      {
        "name": "totalSellVolume",
        "type": "uint256",
        "internalType": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "validateRouter",
    "inputs": [],
    "outputs": [
      {
        "name": "routerValid",
        "type": "bool",
        "internalType": "bool"
      },
      {
        "name": "wethAddress",
        "type": "address",
        "internalType": "address"
      },
      {
        "name": "factoryAddress",
        "type": "address",
        "internalType": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "event",
    "name": "CreatorTransferFeeSet",
    "inputs": [
      {
        "name": "tokenAddress",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "creator",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "transferFeePercent",
        "type": "uint256",
        "indexed": false,
        "internalType": "uint256"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "DEXRouterUpdated",
    "inputs": [
      {
        "name": "oldRouter",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "newRouter",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "EmergencyWithdrawal",
    "inputs": [
      {
        "name": "tokenAddress",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "recipient",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "tokenAmount",
        "type": "uint256",
        "indexed": false,
        "internalType": "uint256"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "FeePercentUpdated",
    "inputs": [
      {
        "name": "oldFeePercent",
        "type": "uint256",
        "indexed": false,
        "internalType": "uint256"
      },
      {
        "name": "newFeePercent",
        "type": "uint256",
        "indexed": false,
        "internalType": "uint256"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "LPLocked",
    "inputs": [
      {
        "name": "tokenAddress",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "lpTokenAddress",
        "type": "address",
        "indexed": false,
        "internalType": "address"
      },
      {
        "name": "lpAmount",
        "type": "uint256",
        "indexed": false,
        "internalType": "uint256"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "TokenCommented",
    "inputs": [
      {
        "name": "tokenAddress",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "commenter",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "comment",
        "type": "string",
        "indexed": false,
        "internalType": "string"
      },
      {
        "name": "timestamp",
        "type": "uint256",
        "indexed": false,
        "internalType": "uint256"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "TokenCompleted",
    "inputs": [
      {
        "name": "tokenAddress",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "finalSupply",
        "type": "uint256",
        "indexed": false,
        "internalType": "uint256"
      },
      {
        "name": "finalPrice",
        "type": "uint256",
        "indexed": false,
        "internalType": "uint256"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "TokenCreated",
    "inputs": [
      {
        "name": "tokenAddress",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "name",
        "type": "string",
        "indexed": false,
        "internalType": "string"
      },
      {
        "name": "symbol",
        "type": "string",
        "indexed": false,
        "internalType": "string"
      },
      {
        "name": "metadata",
        "type": "string",
        "indexed": false,
        "internalType": "string"
      },
      {
        "name": "creator",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "creatorAllocation",
        "type": "uint256",
        "indexed": false,
        "internalType": "uint256"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "TokenUnlocked",
    "inputs": [
      {
        "name": "tokenAddress",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "creator",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "creatorBoughtAmount",
        "type": "uint256",
        "indexed": false,
        "internalType": "uint256"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "TokensBought",
    "inputs": [
      {
        "name": "tokenAddress",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "buyer",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "paymentAmount",
        "type": "uint256",
        "indexed": false,
        "internalType": "uint256"
      },
      {
        "name": "tokenAmount",
        "type": "uint256",
        "indexed": false,
        "internalType": "uint256"
      },
      {
        "name": "newPrice",
        "type": "uint256",
        "indexed": false,
        "internalType": "uint256"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "TokensSold",
    "inputs": [
      {
        "name": "tokenAddress",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "seller",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "tokenAmount",
        "type": "uint256",
        "indexed": false,
        "internalType": "uint256"
      },
      {
        "name": "paymentAmount",
        "type": "uint256",
        "indexed": false,
        "internalType": "uint256"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "TransferFeeCollected",
    "inputs": [
      {
        "name": "tokenAddress",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "from",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "feeAmount",
        "type": "uint256",
        "indexed": false,
        "internalType": "uint256"
      },
      {
        "name": "creatorShare",
        "type": "uint256",
        "indexed": false,
        "internalType": "uint256"
      },
      {
        "name": "launchpadShare",
        "type": "uint256",
        "indexed": false,
        "internalType": "uint256"
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "TransferFeeEnabled",
    "inputs": [
      {
        "name": "tokenAddress",
        "type": "address",
        "indexed": true,
        "internalType": "address"
      },
      {
        "name": "transferFeePercent",
        "type": "uint256",
        "indexed": false,
        "internalType": "uint256"
      }
    ],
    "anonymous": false
  },
  {
    "type": "error",
    "name": "CreatorBuyLimitExceeded",
    "inputs": []
  },
  {
    "type": "error",
    "name": "ExceedsMaxSupply",
    "inputs": []
  },
  {
    "type": "error",
    "name": "FeeExceedsMaximum",
    "inputs": []
  },
  {
    "type": "error",
    "name": "InsufficientBalance",
    "inputs": []
  },
  {
    "type": "error",
    "name": "InsufficientBondingCurveLiquidity",
    "inputs": []
  },
  {
    "type": "error",
    "name": "InsufficientCirculatingSupply",
    "inputs": []
  },
  {
    "type": "error",
    "name": "InsufficientContractBalance",
    "inputs": []
  },
  {
    "type": "error",
    "name": "InsufficientTokenBalance",
    "inputs": []
  },
  {
    "type": "error",
    "name": "InvalidAddress",
    "inputs": []
  },
  {
    "type": "error",
    "name": "InvalidInput",
    "inputs": []
  },
  {
    "type": "error",
    "name": "InvalidToken",
    "inputs": []
  },
  {
    "type": "error",
    "name": "MustSellTokens",
    "inputs": []
  },
  {
    "type": "error",
    "name": "MustSendPayment",
    "inputs": []
  },
  {
    "type": "error",
    "name": "NoTokensPurchased",
    "inputs": []
  },
  {
    "type": "error",
    "name": "NoTokensToBuy",
    "inputs": []
  },
  {
    "type": "error",
    "name": "NotOwner",
    "inputs": []
  },
  {
    "type": "error",
    "name": "ReentrantCall",
    "inputs": []
  },
  {
    "type": "error",
    "name": "SlippageTooHigh",
    "inputs": []
  },
  {
    "type": "error",
    "name": "SlippageTooHighSell",
    "inputs": []
  },
  {
    "type": "error",
    "name": "TokenLaunchCompleted",
    "inputs": []
  },
  {
    "type": "error",
    "name": "TokenLocked",
    "inputs": []
  },
  {
    "type": "error",
    "name": "TransferFailed",
    "inputs": []
  }
]
[V0_FILE]typescript:file="lib/contract-config.ts"
export const CONTRACT_CONFIG = {
  address: "0x04751938b0C7BEF46639E15178D07E61246395ab",
  chainId: 1155,
  rpcUrl: "https://intuition.calderachain.xyz/http",
  network: {
    name: "Intuition Mainnet",
    rpcUrl: "https://intuition.calderachain.xyz/http",
    currency: "TRUST",
    blockExplorer: "https://intuition.calderaexplorer.xyz/",
  },
} as const
[V0_FILE]typescript:file="lib/contract-functions.ts"
import { getContract, getJsonProvider } from "./web3-provider"
import { parseEther, formatEther, Contract, toBigInt } from "ethers"
import { CONTRACT_CONFIG } from "./contract-config"
import ABI from "./contract-abi.json"

async function delay(ms: number): Promise<void> {
  return new Promise((resolve) => setTimeout(resolve, ms))
}

const ERC20_ABI = [
  "function balanceOf(address owner) view returns (uint256)",
  "function allowance(address owner, address spender) view returns (uint256)",
  "function approve(address spender, uint256 amount) returns (bool)",
  "function transfer(address to, uint256 amount) returns (bool)",
  "function decimals() view returns (uint8)",
  "function symbol() view returns (string)",
  "function name() view returns (string)",
]

function formatAddress(address: string): string {
  if (address.startsWith("0x") && address.length === 42) {
    return address
  }
  throw new Error(`Invalid address format: ${address}`)
}

export async function createToken(name: string, symbol: string, metadata: string) {
  try {
    console.log("[v0] createToken - Starting token creation...")
    console.log("[v0] createToken - Parameters:", { name, symbol, metadata })

    const contract = await getContract()
    console.log("[v0] createToken - Contract obtained, calling createToken...")

    const tx = await contract.createToken(name, symbol, metadata)
    console.log("[v0] createToken - Transaction sent:", tx.hash)

    const receipt = await tx.wait()
    console.log("[v0] createToken - Transaction receipt received:", receipt?.hash)
    console.log("[v0] createToken - Receipt status:", receipt?.status)
    console.log("[v0] createToken - Logs count:", receipt?.logs?.length || 0)

    if (!receipt) {
      throw new Error("Transaction receipt is null")
    }

    if (!receipt.logs || receipt.logs.length === 0) {
      throw new Error("No logs found in transaction receipt")
    }

    let tokenAddress: string | undefined
    
    // Try to find TokenCreated event in logs
    for (let i = 0; i < receipt.logs.length; i++) {
      try {
        const log = receipt.logs[i]
        const parsed = contract.interface.parseLog(log)
        console.log("[v0] createToken - Parsed log event:", parsed?.name)
        
        if (parsed?.name === "TokenCreated") {
          console.log("[v0] createToken - TokenCreated event found!")
          console.log("[v0] createToken - Event args:", parsed.args)
          tokenAddress = parsed.args?.tokenAddress || parsed.args?.[2]
          console.log("[v0] createToken - Token address extracted:", tokenAddress)
          break
        }
      } catch (logError) {
        // Log parsing might fail for other contract's events, continue
        console.log("[v0] createToken - Could not parse log", i, logError)
        continue
      }
    }

    if (!tokenAddress) {
      throw new Error("TokenCreated event not found in transaction logs or tokenAddress is undefined")
    }

    console.log("[v0] createToken - Success! Token created at:", tokenAddress)
    return tokenAddress
  } catch (error) {
    console.error("[v0] createToken - Error:", error)
    throw error
  }
}

export async function buyTokens(tokenAddress: string, trustAmount: string, minTokensOut = "0") {
  try {
    tokenAddress = formatAddress(tokenAddress)

    const trustAmountNum = Number.parseFloat(trustAmount)
    if (isNaN(trustAmountNum) || trustAmountNum <= 0) {
      throw new Error(`Invalid TRUST amount: ${trustAmount}`)
    }

    const contract = await getContract()
    console.log("[v0] buyTokens - Validating token exists...")

    const tokenInfo = await contract.getTokenInfo(tokenAddress)
    if (!tokenInfo || !tokenInfo.creator || tokenInfo.creator === "0x0000000000000000000000000000000000000000") {
      throw new Error("Token does not exist or has not been created yet")
    }

    if (tokenInfo.completed) {
      throw new Error("Token launch has been completed. Trading is disabled.")
    }

    console.log("[v0] buyTokens - Token validated, preparing transaction...")
    console.log("[v0] buyTokens - Parameters:", {
      tokenAddress,
      trustAmount: `${trustAmount} TRUST`,
      trustAmountWei: parseEther(trustAmount).toString(),
      minTokensOut,
    })

    let minTokensOutWei
    if (!minTokensOut || minTokensOut === "0" || Number.parseFloat(minTokensOut) === 0) {
      minTokensOutWei = toBigInt(0)
      console.log("[v0] buyTokens - No minimum tokens requirement (slippage protection disabled)")
    } else {
      minTokensOutWei = parseEther(minTokensOut)
      console.log("[v0] buyTokens - Minimum tokens out:", minTokensOut, "tokens")
    }

    try {
      console.log("[v0] buyTokens - Estimating gas...")
      const gasEstimate = await contract.buyTokens.estimateGas(tokenAddress, minTokensOutWei, {
        value: parseEther(trustAmount),
      })
      console.log("[v0] buyTokens - Gas estimate:", gasEstimate.toString())
    } catch (gasError: any) {
      console.error("[v0] buyTokens - Gas estimation failed:", gasError)

      const errorMessage = gasError.message || gasError.toString()

      if (errorMessage.includes("SlippageTooHigh")) {
        throw new Error(
          "Price changed too much during transaction. Try increasing slippage tolerance or reducing trade amount.",
        )
      } else if (errorMessage.includes("TokenLaunchCompleted")) {
        throw new Error("Token launch has been completed. Trading is no longer available through the bonding curve.")
      } else if (errorMessage.includes("CreatorBuyLimitExceeded")) {
        throw new Error("Creator has reached the maximum buy limit for this token.")
      } else if (errorMessage.includes("ExceedsMaxSupply")) {
        throw new Error("This purchase would exceed the maximum token supply. Try buying a smaller amount.")
      } else if (errorMessage.includes("MustSendETH") || errorMessage.includes("NoTokensToBuy")) {
        throw new Error("Invalid purchase amount. Please enter a valid TRUST amount.")
      } else if (errorMessage.includes("insufficient funds") || errorMessage.includes("sender doesn't have enough")) {
        throw new Error("Insufficient TRUST balance. You need more TRUST tokens to complete this purchase.")
      } else if (errorMessage.includes("execution reverted")) {
        throw new Error(
          "Transaction would fail. Please check: you have enough TRUST, token exists, and launch is not completed.",
        )
      } else if (errorMessage.includes("missing revert data")) {
        throw new Error(
          "Unable to complete transaction. Possible reasons: insufficient TRUST balance, slippage too high, or token launch completed. Please check your wallet balance and try again.",
        )
      }

      throw new Error(`Transaction validation failed: ${errorMessage}`)
    }

    const tx = await contract.buyTokens(tokenAddress, minTokensOutWei, {
      value: parseEther(trustAmount),
    })
    console.log("[v0] buyTokens - Transaction sent:", tx.hash)

    const receipt = await tx.wait()
    console.log("[v0] buyTokens - Transaction confirmed:", receipt?.transactionHash)
    return receipt
  } catch (error: any) {
    console.error("[v0] Failed to buy tokens:", error)

    if (error.message?.includes("user rejected")) {
      throw new Error("Transaction rejected by user")
    } else if (error.message?.includes("insufficient funds")) {
      throw new Error("Insufficient TRUST balance in your wallet")
    } else if (error.message?.includes("execution reverted")) {
      throw new Error("Transaction failed. Please check: token exists, launch not completed, and you have enough TRUST")
    }

    throw error
  }
}

export async function sellTokens(tokenAddress: string, tokenAmount: string, factoryAddress?: string, payoutTo?: string) {
  try {
    const contractAddress = CONTRACT_CONFIG.address
    console.log("[v0] Selling tokens:", {
      tokenAddress,
      tokenAmount,
      contractAddress,
      payoutTo,
      note: "Using hardcoded contract address",
    })

    const { BrowserProvider, Contract, parseEther, formatEther } = await import("ethers")

    if (typeof window === "undefined" || !window.ethereum) {
      throw new Error("No wallet connected")
    }

    const provider = new BrowserProvider(window.ethereum)
    const signer = await provider.getSigner()
    const userAddress = await signer.getAddress()

    const contract = new Contract(contractAddress, ABI, signer)

    const userBalanceBefore = await provider.getBalance(userAddress)
    console.log("[v0] User TRUST balance before sell:", formatEther(userBalanceBefore), "TRUST")

    const tokenContract = new Contract(tokenAddress, ERC20_ABI, signer)

    const userTokenBalance = await tokenContract.balanceOf(userAddress)
    console.log("[v0] User token balance:", formatEther(userTokenBalance), "tokens")

    const amountToSell = parseEther(tokenAmount)
    if (userTokenBalance < amountToSell) {
      throw new Error(
        `Insufficient token balance. You have ${formatEther(userTokenBalance)} tokens but trying to sell ${tokenAmount}`,
      )
    }

    const currentAllowance = await tokenContract.allowance(userAddress, contractAddress)
    console.log("[v0] Current allowance:", formatEther(currentAllowance))

    if (currentAllowance < amountToSell) {
      console.log("[v0] Approving token contract for selling...")
      const approveTx = await tokenContract.approve(contractAddress, amountToSell)
      await approveTx.wait()
      console.log("[v0] Approval successful")
    }

    // Determine payout address - use provided payoutTo or default to user address
    const payoutAddress = payoutTo && payoutTo !== userAddress ? payoutTo : userAddress
    console.log("[v0] Payout address:", payoutAddress)

    // Using 0 for minPaymentOut to allow any slippage
    const minPaymentOut = toBigInt(0)
    console.log("[v0] Executing sell transaction with minPaymentOut:", minPaymentOut.toString())
    const tx = await contract.sellTokens(tokenAddress, amountToSell, minPaymentOut, payoutAddress)
    console.log("[v0] Sell transaction sent:", tx.hash)

    const receipt = await tx.wait()
    console.log("[v0] Sell transaction confirmed:", receipt?.hash)
    console.log("[v0] Transaction status:", receipt?.status)

    let ethReceived = 0n
    if (receipt?.logs) {
      for (const log of receipt.logs) {
        try {
          const parsed = contract.interface.parseLog({
            topics: log.topics as string[],
            data: log.data,
          })
          if (parsed?.name === "TokensSold") {
            console.log("[v0] TokensSold event found!")
            ethReceived = parsed.args[2]
            console.log("[v0] TRUST received from event:", formatEther(ethReceived), "TRUST")
          }
        } catch {
          // Not our event, skip
        }
      }
    }

    await new Promise((resolve) => setTimeout(resolve, 2000))

    const userBalanceAfter = await provider.getBalance(userAddress)
    console.log("[v0] User TRUST balance after sell:", formatEther(userBalanceAfter), "TRUST")

    const balanceDiff = userBalanceAfter - userBalanceBefore
    console.log("[v0] Balance difference:", formatEther(balanceDiff), "TRUST")

    return receipt?.hash
  } catch (error: any) {
    console.error("[v0] Sell error:", error)

    const errorMessage = error.message || ""
    if (errorMessage.includes("TokenLocked")) {
      throw new Error("Token is locked. The creator needs to buy more tokens to unlock selling.")
    } else if (errorMessage.includes("InsufficientBalance")) {
      throw new Error("Insufficient token balance.")
    } else if (errorMessage.includes("user rejected")) {
      throw new Error("Transaction rejected by user.")
    }

    throw error
  }
}

export async function getTokenInfo(tokenAddress: string) {
  try {
    tokenAddress = formatAddress(tokenAddress)
    
    const provider = await getJsonProvider()
    const contract = new Contract(CONTRACT_CONFIG.address, ABI, provider)
    
    console.log("[v0] getTokenInfo - Fetching info for:", tokenAddress)
    const tokenInfo = await contract.getTokenInfo(tokenAddress)
    
    console.log("[v0] getTokenInfo - Retrieved:", tokenInfo)
    return tokenInfo
  } catch (error) {
    console.error("Failed to get token info:", error)
    throw error
  }
}

export async function getTokenInfoWithRetry(
  tokenAddress: string,
  maxRetries = 3,
  delayMs = 1500,
): Promise<ReturnType<typeof getTokenInfo>> {
  let lastError: Error | null = null

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      if (attempt > 0) {
        console.log(`[v0] Waiting ${delayMs}ms before retry...`)
        await delay(delayMs)
      }

      const info = await getTokenInfo(tokenAddress)
      if (info === null) {
        throw new Error("Token info not available yet")
      }
      console.log("[v0] Token info fetched successfully")
      return info
    } catch (error) {
      console.log(`[v0] Token info fetch attempt ${attempt + 1} failed`)
      lastError = error as Error
    }
  }

  console.log("[v0] All retry attempts failed, token data will not be updated")
  return null
}

export async function getCurrentPrice(tokenAddress: string) {
  try {
    const contract = await getContract()
    const price = await contract.getCurrentPrice(tokenAddress)

    if (!price || price === null) {
      console.log("[v0] Price not yet available")
      return null
    }

    return formatEther(price)
  } catch (error) {
    console.error("[v0] Failed to get current price:", error)
    return null
  }
}

export async function getTokenTVT(tokenAddress: string): Promise<string> {
  try {
    const provider = await getJsonProvider()
    const contract = new Contract(CONTRACT_CONFIG.address, ABI, provider)
    const tvt = await contract.tokenTotalValueTraded(tokenAddress)
    return formatEther(tvt)
  } catch (error) {
    console.error("Failed to get token TVT:", error)
    return "0"
  }
}

export async function getTotalTVT(): Promise<string> {
  try {
    const { fetchAllTokens } = await import("./tokens")

    const tokens = await fetchAllTokens()
    let totalTVT = 0

    for (const token of tokens) {
      try {
        const tvt = await getTokenTVT(token.contractAddress)
        totalTVT += Number.parseFloat(tvt)
      } catch (error) {
        console.log(`[v0] Failed to get TVT for token ${token.contractAddress}, skipping...`)
      }
    }

    return totalTVT.toString()
  } catch (error) {
    console.error("Failed to get total TVT:", error)
    return "0"
  }
}

export async function setTokenBuySpread(tokenAddress: string, spreadPercent: number) {
  try {
    tokenAddress = formatAddress(tokenAddress)
    console.log("[v0] setTokenBuySpread - Setting buy spread:", { tokenAddress, spreadPercent })

    const contract = await getContract()
    const tx = await contract.setTokenBuySpread(tokenAddress, spreadPercent)
    const receipt = await tx.wait()

    console.log("[v0] setTokenBuySpread - Success!")
    return receipt
  } catch (error) {
    console.error("Failed to set token buy spread:", error)
    throw error
  }
}

export async function setTokenSellSpread(tokenAddress: string, spreadPercent: number) {
  try {
    tokenAddress = formatAddress(tokenAddress)
    console.log("[v0] setTokenSellSpread - Setting sell spread:", { tokenAddress, spreadPercent })

    const contract = await getContract()
    const tx = await contract.setTokenSellSpread(tokenAddress, spreadPercent)
    const receipt = await tx.wait()

    console.log("[v0] setTokenSellSpread - Success!")
    return receipt
  } catch (error) {
    console.error("Failed to set token sell spread:", error)
    throw error
  }
}

export async function emergencyWithdraw(tokenAddress: string) {
  try {
    tokenAddress = formatAddress(tokenAddress)
    console.log("[v0] emergencyWithdraw - Initiating emergency withdrawal:", { tokenAddress })

    const contract = await getContract()
    const tx = await contract.emergencyWithdraw(tokenAddress)
    const receipt = await tx.wait()

    console.log("[v0] emergencyWithdraw - Success!")
    return receipt
  } catch (error) {
    console.error("Failed to perform emergency withdrawal:", error)
    throw error
  }
}

export async function setDexRouter(routerAddress: string) {
  try {
    routerAddress = formatAddress(routerAddress)
    console.log("[v0] setDexRouter - Setting DEX router:", { routerAddress })

    const contract = await getContract()
    const tx = await contract.setDexRouter(routerAddress)
    const receipt = await tx.wait()

    console.log("[v0] setDexRouter - Success!")
    return receipt
  } catch (error) {
    console.error("Failed to set DEX router:", error)
    throw error
  }
}

export async function getUserTokenBalance(tokenAddress: string, userAddress: string) {
  try {
    const contract = await getContract()
    const signer = await contract.runner

    const tokenContract = new Contract(tokenAddress, ERC20_ABI, signer)

    const balance = await tokenContract.balanceOf(userAddress)
    return formatEther(balance)
  } catch (error) {
    console.error("Failed to get user token balance:", error)
    return "0"
  }
}

export async function calculateMarketCap(tokenAddress: string): Promise<number> {
  try {
    const info = await getTokenInfo(tokenAddress)
    if (!info) {
      return 0
    }

    const price = await getCurrentPrice(tokenAddress)
    if (!price) {
      return 0
    }

    const currentSupply = Number.parseFloat(info.currentSupply)
    const currentPrice = Number.parseFloat(price)

    return currentSupply * currentPrice
  } catch (error) {
    console.error("Failed to calculate market cap:", error)
    return 0
  }
}

export async function addTokenComment(tokenAddress: string, commentText: string) {
  try {
    const contract = await getContract()

    const commentFee = parseEther("0.025")

    const tx = await contract.addComment(tokenAddress, commentText, {
      value: commentFee,
    })

    console.log("Comment transaction sent:", tx.hash)
    const receipt = await tx.wait()
    console.log("Comment posted successfully")
    return receipt
  } catch (error: any) {
    console.error("Failed to add comment:", error)

    if (error.message?.includes("user rejected")) {
      throw new Error("Transaction rejected by user")
    } else if (error.message?.includes("insufficient funds")) {
      throw new Error("Insufficient TRUST balance to post comment")
    }

    throw error
  }
}

export async function getTokenHolderBalance(tokenAddress: string, holderAddress: string): Promise<string> {
  try {
    const jsonProvider = await getJsonProvider()
    const tokenContract = new Contract(tokenAddress, ERC20_ABI, jsonProvider)
    const balance = await tokenContract.balanceOf(holderAddress)
    return formatEther(balance)
  } catch (error) {
    console.error("Failed to get holder balance:", error)
    return "0"
  }
}

export async function isTokenUnlocked(tokenAddress: string): Promise<boolean> {
  try {
    const jsonProvider = await getJsonProvider()

    const readOnlyContract = new Contract(CONTRACT_CONFIG.address, ABI, jsonProvider)
    const isUnlocked = await readOnlyContract.tokenUnlocked(tokenAddress)
    return isUnlocked
  } catch (error) {
    console.error("Failed to check token unlock status:", error)
    return false
  }
}

export async function getUserVolume(userAddress: string): Promise<{ buyVolume: string; sellVolume: string; totalVolume: string }> {
  try {
    console.log(`[v0] getUserVolume START for: ${userAddress}`)

    userAddress = formatAddress(userAddress)

    const jsonProvider = await getJsonProvider()
    const readOnlyContract = new Contract(CONTRACT_CONFIG.address, ABI, jsonProvider)

    // Use userVolumes mapping instead of getUserVolume function
    const volumes = await readOnlyContract.userVolumes(userAddress)

    const buyVolume = formatEther(volumes.totalBuyVolume || 0n)
    const sellVolume = formatEther(volumes.totalSellVolume || 0n)
    const totalVolume = (Number.parseFloat(buyVolume) + Number.parseFloat(sellVolume)).toString()

    console.log(
      `[v0] getUserVolume SUCCESS - ${userAddress}: Buy=${buyVolume}, Sell=${sellVolume}, Total=${totalVolume}`,
    )

    return { buyVolume, sellVolume, totalVolume }
  } catch (error) {
    console.error(`[v0] getUserVolume FAILED for ${userAddress}:`, error)
    return { buyVolume: "0", sellVolume: "0", totalVolume: "0" }
  }
}

export async function getAllTokenAddresses(): Promise<string[]> {
  try {
    const { fetchAllTokens } = await import("./tokens")
    const tokens = await fetchAllTokens()
    return tokens.map((token) => token.contractAddress)
  } catch (error) {
    console.error("Failed to get all token addresses:", error)
    return []
  }
}

export async function getCurveLiquidity(tokenAddress: string): Promise<string> {
  try {
    const jsonProvider = await getJsonProvider()
    const readOnlyContract = new Contract(CONTRACT_CONFIG.address, ABI, jsonProvider)
    const liquidity = await readOnlyContract.curveLiquidity(tokenAddress)
    return formatEther(liquidity)
  } catch (error) {
    console.error("Failed to get curve liquidity:", error)
    return "0"
  }
}
[V0_FILE]typescript:file="lib/contract-import.ts"
import { ethers } from "ethers"
import { CONTRACT_CONFIG } from "./contract-config"
import CONTRACT_ABI from "./contract-abi.json"
import { createTokenInDatabase } from "./tokens"
import { getAllTokenAddresses } from "./contract-functions"

const RPC_URL = CONTRACT_CONFIG.network.rpcUrl
const CONTRACT_ADDRESS = CONTRACT_CONFIG.address

export async function getAllTokensFromContract() {
  try {
    console.log("[v0] Fetching tokens from contract:", CONTRACT_ADDRESS)
    const provider = new ethers.JsonRpcProvider(RPC_URL)
    const contract = new ethers.Contract(CONTRACT_ADDRESS, CONTRACT_ABI, provider)

    const tokenAddresses = await getAllTokenAddresses()
    console.log("[v0] Found", tokenAddresses.length, "tokens on contract")

    const tokens = []
    for (const tokenAddress of tokenAddresses) {
      try {
        const tokenInfo = await contract.getTokenInfo(tokenAddress)
        const currentPrice = await contract.getCurrentPrice(tokenAddress)

        tokens.push({
          address: tokenAddress,
          name: tokenInfo.name,
          symbol: tokenInfo.symbol,
          metadata: tokenInfo.metadata,
          creator: tokenInfo.creator,
          heldTokens: tokenInfo.heldTokens.toString(),
          maxSupply: tokenInfo.maxSupply.toString(),
          currentSupply: tokenInfo.currentSupply.toString(),
          completed: tokenInfo.completed,
          creationTime: tokenInfo.creationTime.toString(),
          currentPrice: currentPrice.toString(),
        })
      } catch (error) {
        console.error(`[v0] Error fetching info for token ${tokenAddress}:`, error)
      }
    }

    return tokens
  } catch (error) {
    console.error("[v0] Error fetching tokens from contract:", error)
    throw error
  }
}

export async function importTokensFromContract() {
  try {
    const tokens = await getAllTokensFromContract()
    console.log("[v0] Importing", tokens.length, "tokens to database")

    let imported = 0
    let skipped = 0

    for (const token of tokens) {
      try {
        // Parse metadata JSON
        let imageUrl = "/placeholder.svg?height=400&width=400"
        let description = ""

        try {
          const metadata = JSON.parse(token.metadata)
          imageUrl = metadata.image || imageUrl
          description = metadata.description || ""
        } catch {
          // If metadata is not JSON, use it as description
          description = token.metadata
        }

        // Calculate market cap and start price
        const currentPriceEth = Number.parseFloat(ethers.formatEther(token.currentPrice))
        const currentSupplyEth = Number.parseFloat(ethers.formatEther(token.currentSupply))
        const maxSupplyEth = Number.parseFloat(ethers.formatEther(token.maxSupply))
        const marketCap = currentPriceEth * currentSupplyEth

        const result = await createTokenInDatabase({
          name: token.name,
          symbol: token.symbol,
          contractAddress: token.address.toLowerCase(),
          creatorAddress: token.creator.toLowerCase(),
          imageUrl,
          description,
          currentPrice: currentPriceEth.toString(),
          marketCap: marketCap.toString(),
          maxSupply: maxSupplyEth.toString(),
          currentSupply: currentSupplyEth.toString(),
          startPrice: "0.00001", // Default start price
          factoryAddress: CONTRACT_ADDRESS.toLowerCase(),
        })

        if (result) {
          imported++
          console.log(`[v0] Imported token: ${token.name} (${token.symbol})`)
        } else {
          skipped++
          console.log(`[v0] Skipped existing token: ${token.name} (${token.symbol})`)
        }
      } catch (error) {
        console.error(`[v0] Error importing token ${token.name}:`, error)
        skipped++
      }
    }

    return { success: true, imported, skipped, total: tokens.length }
  } catch (error) {
    console.error("[v0] Error in importTokensFromContract:", error)
    return { success: false, error: error instanceof Error ? error.message : "Unknown error" }
  }
}
[V0_FILE]typescript:file="lib/holder-tracking.ts"
import { getUserTokenBalance } from "@/lib/contract-functions"
import { updateTokenInDatabase } from "@/lib/tokens"

// Track a holder for a token (call this after buy/sell transactions)
export async function trackTokenHolder(tokenAddress: string, holderAddress: string): Promise<void> {
  try {
    console.log(`[v0] Checking balance for ${holderAddress} on token ${tokenAddress}`)

    // Get the actual balance from the blockchain
    const balance = await getUserTokenBalance(tokenAddress, holderAddress)
    const balanceNum = Number.parseFloat(balance)

    console.log(`[v0] Holder balance: ${balanceNum}`)

    // For now, we'll just increment the holder count in the database
    // This is a simple approach since we don't have event indexing
    // A more accurate solution would require querying all Transfer events

    // Only consider as a holder if balance > 0
    if (balanceNum > 0) {
      console.log(`[v0] User is a holder (balance > 0)`)
      // Update the holder record directly in meme_tokens table
      await updateTokenInDatabase(tokenAddress, { holders: balanceNum > 0 ? 1 : 0 })
    } else {
      console.log(`[v0] User is not a holder (balance = 0)`)
    }
  } catch (error) {
    console.error("[v0] Failed to track holder:", error)
  }
}

// Get estimated holder count for a token
// Note: This is a placeholder implementation
// A proper solution would require indexing blockchain events
export async function getTokenHolderCount(tokenAddress: string): Promise<number> {
  console.log("[v0] getTokenHolderCount called - returning placeholder value")
  // Return 1 as default since we can't accurately count without event indexing
  return 1
}
[V0_FILE]typescript:file="lib/leaderboard.ts"
import { createBrowserClient } from "./supabase/client"
import { getUserVolume } from "./contract-functions"

export interface LeaderboardTrader {
  address: string
  totalVolume: string
  buyVolume: string
  sellVolume: string
  rank: number
  displayName?: string
}

export interface LeaderboardUser {
  address: string
  points: number
  tradingPoints: number
  commentPoints: number
  rank: number
  displayName?: string
}

export async function getTopTraders(limit = 25): Promise<LeaderboardTrader[]> {
  try {
    console.log("[v0] Getting top traders from blockchain...")

    const supabase = createBrowserClient()

    // Get all unique addresses from token_trades table
    const { data: trades, error } = await supabase.from("token_trades").select("trader_address").limit(1000)

    if (error) {
      console.error("[v0] Error fetching trades:", error)
      return []
    }

    const uniqueAddresses = [...new Set(trades?.map((t) => t.trader_address.toLowerCase()) || [])]
    console.log(`[v0] Found ${uniqueAddresses.length} unique addresses from trades`)

    if (uniqueAddresses.length === 0) {
      console.log("[v0] No traders found")
      return []
    }

    // Fetch volumes for each unique address
    const traderVolumes = await Promise.all(
      uniqueAddresses.map(async (address) => {
        const volume = await getUserVolume(address)
        return {
          address,
          ...volume,
        }
      }),
    )

    console.log(`[v0] Fetched volumes for ${traderVolumes.length} traders`)

    // Filter traders with actual volume and sort
    const traders: LeaderboardTrader[] = traderVolumes
      .filter((trader) => {
        const totalVol = Number.parseFloat(trader.totalVolume)
        if (totalVol > 0) {
          console.log(`[v0] Trader ${trader.address}: ${trader.totalVolume} TRUST total volume`)
        }
        return totalVol > 0
      })
      .sort((a, b) => Number.parseFloat(b.totalVolume) - Number.parseFloat(a.totalVolume))
      .slice(0, limit)
      .map((trader, index) => ({
        ...trader,
        rank: index + 1,
      }))

    console.log(`[v0] Returning ${traders.length} traders with volume > 0`)
    return traders
  } catch (error) {
    console.error("[v0] Error getting top traders:", error)
    return []
  }
}

export async function getMostActiveUsers(limit = 25): Promise<LeaderboardUser[]> {
  try {
    const supabase = createBrowserClient()

    if (!supabase) {
      console.error("[v0] Supabase client not available")
      return []
    }

    const { data: users, error } = await supabase
      .from("user_points")
      .select("wallet_address, points, trading_points, comment_points")
      .order("points", { ascending: false })
      .limit(limit)

    if (error) {
      console.error("[v0] Error fetching most active users:", error)
      return []
    }

    if (!users || users.length === 0) {
      return []
    }

    // Get display names from user_profiles if they exist
    const addresses = users.map((u) => u.wallet_address)
    const { data: profiles } = await supabase
      .from("user_profiles")
      .select("wallet_address, display_name")
      .in("wallet_address", addresses)

    const profileMap = new Map(profiles?.map((p) => [p.wallet_address, p.display_name]) || [])

    return users.map((user, index) => ({
      address: user.wallet_address,
      points: Number(user.points || 0),
      tradingPoints: Number(user.trading_points || 0),
      commentPoints: Number(user.comment_points || 0),
      rank: index + 1,
      displayName: profileMap.get(user.wallet_address),
    }))
  } catch (error) {
    console.error("[v0] Error getting most active users:", error)
    return []
  }
}

export async function getTopTradersFromDB(limit = 25): Promise<LeaderboardTrader[]> {
  try {
    console.log("[v0] Getting top traders from database...")
    const supabase = createBrowserClient()

    if (!supabase) {
      console.error("[v0] Supabase client not available")
      return []
    }

    const { data: allUsers, error: countError } = await supabase
      .from("user_points")
      .select("wallet_address, total_volume")
      .limit(100)

    console.log("[v0] Total user_points rows:", allUsers?.length || 0)
    if (allUsers && allUsers.length > 0) {
      console.log("[v0] Sample user_points data:", allUsers.slice(0, 3))
    }

    // Query user_points table for users with trading volume
    const { data: traders, error } = await supabase
      .from("user_points")
      .select("wallet_address, total_volume, total_buy_volume, total_sell_volume")
      .gt("total_volume", 0)
      .order("total_volume", { ascending: false })
      .limit(limit)

    if (error) {
      console.error("[v0] Error fetching top traders:", error)
      return []
    }

    console.log("[v0] Found traders with volume > 0:", traders?.length || 0)

    if (!traders || traders.length === 0) {
      console.log("[v0] No traders found in database with volume > 0")
      return []
    }

    // Get display names from user_profiles
    const addresses = traders.map((t) => t.wallet_address)
    const { data: profiles } = await supabase
      .from("user_profiles")
      .select("wallet_address, display_name")
      .in("wallet_address", addresses)

    const profileMap = new Map(profiles?.map((p) => [p.wallet_address, p.display_name]) || [])

    return traders.map((trader, index) => ({
      address: trader.wallet_address,
      totalVolume: trader.total_volume?.toString() || "0",
      buyVolume: trader.total_buy_volume?.toString() || "0",
      sellVolume: trader.total_sell_volume?.toString() || "0",
      rank: index + 1,
      displayName: profileMap.get(trader.wallet_address),
    }))
  } catch (error) {
    console.error("[v0] Error getting top traders from DB:", error)
    return []
  }
}

export async function getAllTopTraders(limit = 25): Promise<LeaderboardTrader[]> {
  // Same implementation as getTopTraders but for server-side use
  return getTopTraders(limit)
}

export async function getTopUsersByPoints(limit = 25): Promise<LeaderboardUser[]> {
  // Same implementation as getMostActiveUsers but with better naming
  return getMostActiveUsers(limit)
}

export async function getCachedLeaderboard(type: "top_traders" | "most_active") {
  try {
    const supabase = createBrowserClient()

    if (!supabase) {
      console.error("[v0] Supabase client not available")
      return null
    }

    const { data, error } = await supabase
      .from("leaderboard_cache")
      .select("data, last_updated")
      .eq("cache_type", type)
      .limit(1)

    if (error) {
      console.error(`[v0] Error fetching ${type} cache:`, error)
      return null
    }

    if (!data || data.length === 0) {
      console.log(`[v0] No cached data found for ${type}`)
      return null
    }

    return data[0]
  } catch (error) {
    console.error(`[v0] Error getting cached ${type}:`, error)
    return null
  }
}

export function shouldRefreshCache(lastUpdated: string | null): boolean {
  if (!lastUpdated) return true

  const lastUpdate = new Date(lastUpdated)
  const now = new Date()
  const hoursSinceUpdate = (now.getTime() - lastUpdate.getTime()) / (1000 * 60 * 60)

  return hoursSinceUpdate >= 24
}
[V0_FILE]typescript:file="lib/mock-data.ts"
export const mockTokens: any[] = []
[V0_FILE]typescript:file="lib/points-system.ts"
import { createBrowserClient } from "./supabase/client"
import { getUserVolume } from "./contract-functions"

// Points calculation constant (k value)
// Adjust this to scale the points (higher k = more points)
const POINTS_MULTIPLIER = 10

/**
 * Calculate points using anti-whale logarithmic formula
 * Points = k × log(1 + Trade Volume)
 *
 * This prevents whales from dominating while still rewarding higher volume
 */
export function calculatePoints(tradeVolume: number): number {
  if (tradeVolume <= 0) return 0

  // Using natural logarithm (Math.log is ln in JavaScript)
  const points = POINTS_MULTIPLIER * Math.log(1 + tradeVolume)

  return Math.max(0, points) // Ensure non-negative
}

/**
 * Fetch user's trading volume from the blockchain
 * Use getUserVolume helper that uses userVolumes mapping
 */
export async function getUserVolumeFromBlockchain(walletAddress: string): Promise<{
  buyVolume: number
  sellVolume: number
  totalVolume: number
}> {
  try {
    const volume = await getUserVolume(walletAddress)

    return {
      buyVolume: Number.parseFloat(volume.buyVolume),
      sellVolume: Number.parseFloat(volume.sellVolume),
      totalVolume: Number.parseFloat(volume.totalVolume),
    }
  } catch (error) {
    console.error("[v0] Failed to fetch user volume from blockchain:", error)
    return { buyVolume: 0, sellVolume: 0, totalVolume: 0 }
  }
}

/**
 * Update user points in the database based on their blockchain trading volume
 */
export async function updateUserPoints(walletAddress: string): Promise<{
  totalVolume: number
  points: number
} | null> {
  try {
    const supabase = createBrowserClient()

    // Fetch volume from blockchain
    const { buyVolume, sellVolume, totalVolume } = await getUserVolumeFromBlockchain(walletAddress)

    // Calculate points from trading volume using anti-whale formula
    const tradingPoints = calculatePoints(totalVolume)

    const { data: existingData } = await supabase
      .from("user_points")
      .select("comment_points")
      .eq("wallet_address", walletAddress.toLowerCase())
      .single()

    const commentPoints = existingData?.comment_points ? Number(existingData.comment_points) : 0

    // Total points = trading points + comment points
    const totalPoints = tradingPoints + commentPoints

    console.log("[v0] Updating points for", walletAddress, {
      buyVolume,
      sellVolume,
      totalVolume,
      tradingPoints,
      commentPoints,
      totalPoints,
    })

    // Upsert user points in database
    const { data, error } = await supabase
      .from("user_points")
      .upsert(
        {
          wallet_address: walletAddress.toLowerCase(),
          total_buy_volume: buyVolume,
          total_sell_volume: sellVolume,
          total_volume: totalVolume,
          trading_points: tradingPoints,
          comment_points: commentPoints,
          points: totalPoints,
          last_updated: new Date().toISOString(),
        },
        {
          onConflict: "wallet_address",
        },
      )
      .select()
      .single()

    if (error) {
      // If table doesn't exist, still return the calculated values
      if (error.message?.includes("Could not find the table")) {
        console.warn(
          "[v0] user_points table not found. Please run the migration script: scripts/007_create_user_points_table.sql",
        )
        return { totalVolume, points: totalPoints }
      }
      console.error("[v0] Failed to update user points in database:", error)
      return null
    }

    return { totalVolume, points: totalPoints }
  } catch (error) {
    console.error("[v0] Error updating user points:", error)
    return null
  }
}

/**
 * Get user points from database
 */
export async function getUserPoints(walletAddress: string): Promise<{
  totalVolume: number
  points: number
  buyVolume: number
  sellVolume: number
  lastUpdated: string
} | null> {
  try {
    const supabase = createBrowserClient()

    const { data, error } = await supabase
      .from("user_points")
      .select("*")
      .eq("wallet_address", walletAddress.toLowerCase())
      .single()

    if (error) {
      // If table doesn't exist, fetch directly from blockchain
      if (error.message?.includes("Could not find the table")) {
        console.warn("[v0] user_points table not found. Fetching directly from blockchain...")
        const { buyVolume, sellVolume, totalVolume } = await getUserVolumeFromBlockchain(walletAddress)
        const tradingPoints = calculatePoints(totalVolume)
        const commentPoints = 0
        const totalPoints = tradingPoints + commentPoints

        return {
          totalVolume,
          points: totalPoints,
          buyVolume,
          sellVolume,
          lastUpdated: new Date().toISOString(),
        }
      }

      // No record exists, fetch from blockchain and try to create it
      if (error.code === "PGRST116") {
        console.log("[v0] No points record found for user, fetching from blockchain...")
        const result = await updateUserPoints(walletAddress)
        if (!result) return null

        // Fetch volumes again for complete data
        const { buyVolume, sellVolume } = await getUserVolumeFromBlockchain(walletAddress)
        return {
          totalVolume: result.totalVolume,
          points: result.points,
          buyVolume,
          sellVolume,
          lastUpdated: new Date().toISOString(),
        }
      }

      console.error("[v0] Error fetching user points:", error)
      return null
    }

    if (!data) {
      console.log("[v0] No points record found for user, fetching from blockchain...")
      const result = await updateUserPoints(walletAddress)
      if (!result) return null

      const { buyVolume, sellVolume } = await getUserVolumeFromBlockchain(walletAddress)
      return {
        totalVolume: result.totalVolume,
        points: result.points,
        buyVolume,
        sellVolume,
        lastUpdated: new Date().toISOString(),
      }
    }

    return {
      totalVolume: Number(data.total_volume),
      points: Number(data.points),
      buyVolume: Number(data.total_buy_volume),
      sellVolume: Number(data.total_sell_volume),
      lastUpdated: data.last_updated,
    }
  } catch (error) {
    console.error("[v0] Error fetching user points:", error)
    return null
  }
}

/**
 * Get leaderboard (top users by points)
 */
export async function getPointsLeaderboard(limit = 100): Promise<
  Array<{
    walletAddress: string
    points: number
    totalVolume: number
  }>
> {
  try {
    const supabase = createBrowserClient()

    const { data, error } = await supabase
      .from("user_points")
      .select("wallet_address, points, total_volume")
      .order("points", { ascending: false })
      .limit(limit)

    if (error || !data) {
      console.error("[v0] Failed to fetch leaderboard:", error)
      return []
    }

    return data.map((row) => ({
      walletAddress: row.wallet_address,
      points: Number(row.points),
      totalVolume: Number(row.total_volume),
    }))
  } catch (error) {
    console.error("[v0] Error fetching leaderboard:", error)
    return []
  }
}

/**
 * Award points for posting a comment
 * Fixed reward: 0.025 points per comment
 */
export async function awardCommentPoints(walletAddress: string): Promise<boolean> {
  try {
    const supabase = createBrowserClient()
    const COMMENT_POINTS = 0.025

    const { data: currentData, error: fetchError } = await supabase
      .from("user_points")
      .select("points, comment_points, trading_points, total_volume, total_buy_volume, total_sell_volume")
      .eq("wallet_address", walletAddress.toLowerCase())
      .single()

    let newCommentPoints = COMMENT_POINTS
    let tradingPoints = 0
    let totalVolume = 0
    let buyVolume = 0
    let sellVolume = 0

    if (currentData && !fetchError) {
      // User exists, add to their comment points
      newCommentPoints = (Number(currentData.comment_points) || 0) + COMMENT_POINTS
      tradingPoints = Number(currentData.trading_points) || 0
      totalVolume = Number(currentData.total_volume) || 0
      buyVolume = Number(currentData.total_buy_volume) || 0
      sellVolume = Number(currentData.total_sell_volume) || 0
    }

    const totalPoints = tradingPoints + newCommentPoints

    // Upsert the points
    const { error: upsertError } = await supabase.from("user_points").upsert(
      {
        wallet_address: walletAddress.toLowerCase(),
        trading_points: tradingPoints,
        comment_points: newCommentPoints,
        points: totalPoints,
        total_volume: totalVolume,
        total_buy_volume: buyVolume,
        total_sell_volume: sellVolume,
        last_updated: new Date().toISOString(),
      },
      {
        onConflict: "wallet_address",
      },
    )

    if (upsertError) {
      console.error("[v0] Failed to award comment points:", upsertError)
      return false
    }

    console.log(
      "[v0] Awarded",
      COMMENT_POINTS,
      "points for comment to",
      walletAddress,
      "Total comment points:",
      newCommentPoints,
    )
    return true
  } catch (error) {
    console.error("[v0] Error awarding comment points:", error)
    return false
  }
}
[V0_FILE]typescript:file="lib/starred-tokens.ts"
"use client"

import { createBrowserClient } from "@/lib/supabase/client"

export async function toggleStarToken(userAddress: string, tokenAddress: string): Promise<boolean> {
  console.log("[v0] toggleStarToken called:", { userAddress, tokenAddress })

  const supabase = createBrowserClient()
  if (!supabase) {
    console.error("[v0] Supabase client not available")
    return false
  }

  try {
    // Check if already starred
    console.log("[v0] Checking if token is already starred...")
    const { data: existing, error: checkError } = await supabase
      .from("starred_tokens")
      .select("id")
      .eq("user_address", userAddress.toLowerCase())
      .eq("token_address", tokenAddress.toLowerCase())
      .single()

    if (checkError && checkError.code !== "PGRST116") {
      console.error("[v0] Error checking star status:", checkError)
      throw checkError
    }

    if (existing) {
      // Unstar
      console.log("[v0] Token is starred, unstaring...")
      const { error } = await supabase
        .from("starred_tokens")
        .delete()
        .eq("user_address", userAddress.toLowerCase())
        .eq("token_address", tokenAddress.toLowerCase())

      if (error) {
        console.error("[v0] Error unstaring token:", error)
        throw error
      }
      console.log("[v0] Token unstarred successfully")
      return false // Now unstarred
    } else {
      // Star
      console.log("[v0] Token is not starred, starring...")
      const { error } = await supabase.from("starred_tokens").insert({
        user_address: userAddress.toLowerCase(),
        token_address: tokenAddress.toLowerCase(),
      })

      if (error) {
        console.error("[v0] Error starring token:", error)
        throw error
      }
      console.log("[v0] Token starred successfully")
      return true // Now starred
    }
  } catch (error) {
    console.error("[v0] Error toggling star:", error)
    throw error
  }
}

export async function getStarredTokens(userAddress: string): Promise<string[]> {
  // Return empty array if no user address provided
  if (!userAddress) {
    return []
  }

  try {
    const supabase = createBrowserClient()
    if (!supabase) {
      console.log("[v0] Supabase client not available for getStarredTokens")
      return []
    }

    const { data, error } = await supabase
      .from("starred_tokens")
      .select("token_address")
      .eq("user_address", userAddress.toLowerCase())

    if (error) {
      // Don't throw, just log and return empty array
      console.log("[v0] Error fetching starred tokens (non-critical):", error.message)
      return []
    }

    return data?.map((item) => item.token_address) || []
  } catch (error) {
    // Catch any network errors and return empty array
    console.log("[v0] Network error fetching starred tokens (non-critical):", error)
    return []
  }
}

export async function isTokenStarred(userAddress: string, tokenAddress: string): Promise<boolean> {
  // Return false if missing parameters
  if (!userAddress || !tokenAddress) {
    return false
  }

  try {
    const supabase = createBrowserClient()
    if (!supabase) return false

    const { data, error } = await supabase
      .from("starred_tokens")
      .select("id")
      .eq("user_address", userAddress.toLowerCase())
      .eq("token_address", tokenAddress.toLowerCase())
      .single()

    if (error) {
      return false
    }

    return !!data
  } catch (error) {
    return false
  }
}
[V0_FILE]typescript:file="lib/supabase/client.ts"
import { createBrowserClient as createSupabaseBrowserClient } from "@supabase/ssr"

export function createBrowserClient() {
  const url = process.env.NEXT_PUBLIC_SUPABASE_URL
  const key = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY

  if (!url || !key) {
    console.warn("[v0] Supabase environment variables are not configured properly")
    // Return a mock client that won't break the build but will log errors when used
    return null as any
  }

  return createSupabaseBrowserClient(url, key)
}

// Keep the original createClient for backwards compatibility
export function createClient() {
  return createBrowserClient()
}

export function createClientComponentClient() {
  return createBrowserClient()
}
[V0_FILE]typescript:file="lib/supabase/server.ts"
import { createServerClient as createSupabaseServerClient } from "@supabase/ssr"
import { cookies } from "next/headers"

export async function createClient() {
  const url = process.env.NEXT_PUBLIC_SUPABASE_URL
  const key = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY

  if (!url || !key) {
    console.warn("[Supabase] Server environment variables are not configured")
    return null as any
  }

  const cookieStore = await cookies()

  return createSupabaseServerClient(url, key, {
    cookies: {
      getAll() {
        return cookieStore.getAll()
      },
      setAll(cookiesToSet) {
        try {
          cookiesToSet.forEach(({ name, value, options }) => 
            cookieStore.set(name, value, options)
          )
        } catch (error) {
          // Ignore errors from Server Components - middleware handles session refresh
        }
      },
    },
  })
}

export const createServerClient = createClient
[V0_FILE]typescript:file="lib/tokens.ts"
import { createClient } from "@/lib/supabase/client"
import { calculateMarketCap } from "@/lib/bonding-curve"

export interface MemeToken {
  id: string
  name: string
  symbol: string
  image: string
  currentPrice: number
  startPrice: number
  marketCap: number
  maxSupply: number
  currentSupply: number
  holders: number
  creator: string
  intuitionLink: string
  isAlpha: boolean
  contractAddress: string
  isCompleted: boolean
  createdAt: string
  factory_address?: string
  isRewind2025?: boolean
  creatorProfile?: {
    displayName?: string
    profileImage?: string
  }
}

interface SupabaseToken {
  id: string
  name: string
  symbol: string
  image: string
  current_price: number
  start_price: number
  market_cap: number
  max_supply: number
  current_supply: number
  holders: number
  creator: string
  intuition_link: string
  is_alpha: boolean
  contract_address: string
  is_completed: boolean
  created_at: string
  factory_address?: string
  is_rewind_2025?: boolean
  user_profiles?: {
    display_name?: string
    profile_image?: string
  } | null
}

// Convert database format to client format
function supabaseToToken(data: SupabaseToken): MemeToken {
  return {
    id: data.id,
    name: data.name,
    symbol: data.symbol,
    image: data.image,
    currentPrice: data.current_price,
    startPrice: data.start_price,
    marketCap: data.market_cap,
    maxSupply: data.max_supply,
    currentSupply: data.current_supply,
    holders: data.holders,
    creator: data.creator,
    intuitionLink: data.intuition_link,
    isAlpha: data.is_alpha,
    contractAddress: data.contract_address,
    isCompleted: data.is_completed,
    createdAt: data.created_at,
    factory_address: data.factory_address,
    isRewind2025: data.is_rewind_2025,
    creatorProfile: data.user_profiles
      ? {
          displayName: data.user_profiles.display_name,
          profileImage: data.user_profiles.profile_image,
        }
      : undefined,
  }
}

// Fetch all tokens from database
export async function fetchAllTokens(): Promise<MemeToken[]> {
  try {
    console.log("[v0] fetchAllTokens called")

    if (typeof window === "undefined") {
      console.log("[v0] fetchAllTokens called on server side, skipping")
      return []
    }

    console.log("[v0] Environment check:", {
      hasUrl: !!process.env.NEXT_PUBLIC_SUPABASE_URL,
      hasKey: !!process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY,
    })

    if (!process.env.NEXT_PUBLIC_SUPABASE_URL || !process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY) {
      console.error("[v0] Supabase environment variables not configured")
      throw new Error("Database not configured. Please contact support.")
    }

    console.log("[v0] Creating Supabase client...")
    const supabase = createClient()

    if (!supabase) {
      console.error("[v0] Supabase client failed to initialize")
      throw new Error("Database connection failed. Please try again.")
    }

    console.log("[v0] Fetching tokens from database...")
    const { data: tokens, error: tokensError } = await supabase
      .from("meme_tokens")
      .select(`
        id,
        name,
        symbol,
        image,
        current_price,
        start_price,
        market_cap,
        max_supply,
        current_supply,
        holders,
        creator,
        intuition_link,
        is_alpha,
        contract_address,
        is_completed,
        created_at,
        factory_address,
        is_rewind_2025
      `)
      .order("created_at", { ascending: false })

    if (tokensError) {
      console.error("[v0] Error fetching tokens from database:", tokensError)
      throw new Error(`Database error: ${tokensError.message}`)
    }

    console.log("[v0] Raw tokens data:", tokens)
    console.log("[v0] Tokens count:", tokens?.length || 0)

    if (!tokens || tokens.length === 0) {
      console.log("[v0] No tokens found in database")
      return []
    }

    console.log("[v0] Fetched", tokens.length, "tokens from database")
    console.log("[v0] Sample token from database:", tokens[0])

    // Fetch creator profiles separately
    const creatorAddresses = [...new Set(tokens.map((t) => t.creator))]
    console.log("[v0] Fetching profiles for creators:", creatorAddresses)

    const { data: profiles } = await supabase
      .from("user_profiles")
      .select("wallet_address, display_name, profile_image")
      .in("wallet_address", creatorAddresses)

    console.log("[v0] Fetched", profiles?.length || 0, "creator profiles")

    // Create a map of profiles for quick lookup
    const profileMap = new Map((profiles || []).map((p) => [p.wallet_address, p]))

    // Merge tokens with profiles
    const result = tokens.map((token) => {
      const profile = profileMap.get(token.creator)
      return supabaseToToken({
        ...token,
        user_profiles: profile
          ? {
              display_name: profile.display_name,
              profile_image: profile.profile_image,
            }
          : null,
      })
    })

    console.log("[v0] Returning", result.length, "formatted tokens")
    console.log("[v0] Sample formatted token:", result[0])
    return result
  } catch (error: any) {
    console.error("[v0] Error fetching tokens:", error)
    throw error
  }
}

export function normalizeIntuitionLink(link: string): string {
  if (!link || link.trim() === "") return ""

  try {
    const url = new URL(link.trim())

    // Expected format: https://portal.intuition.systems/explore/atom/{hash}
    // Extract only the base atom URL without any suffixes or query parameters
    const pathMatch = url.pathname.match(/^\/explore\/atom\/(0x[a-fA-F0-9]+)/)

    if (!pathMatch) {
      throw new Error("Invalid Intuition link format")
    }

    // Return the normalized format without any suffixes or query params
    return `https://portal.intuition.systems/explore/atom/${pathMatch[1]}`
  } catch (error) {
    console.error("[v0] Error normalizing link:", error)
    return ""
  }
}

export function validateIntuitionLink(link: string): { valid: boolean; error?: string; normalized?: string } {
  if (!link || link.trim() === "") {
    return { valid: true, normalized: "" } // Optional field
  }

  // Must start with https://
  if (!link.startsWith("https://")) {
    return { valid: false, error: 'Link must start with "https://"' }
  }

  try {
    const url = new URL(link.trim())

    // Must be from portal.intuition.systems
    if (url.hostname !== "portal.intuition.systems") {
      return { valid: false, error: "Link must be from portal.intuition.systems" }
    }

    // Must match the expected path format: /explore/atom/{hash}
    const pathMatch = url.pathname.match(/^\/explore\/atom\/(0x[a-fA-F0-9]{64})$/)

    if (!pathMatch) {
      return {
        valid: false,
        error: "Link must be in format: https://portal.intuition.systems/explore/atom/0x...",
      }
    }

    const normalized = normalizeIntuitionLink(link)
    return { valid: true, normalized }
  } catch (error) {
    return { valid: false, error: "Invalid URL format" }
  }
}

export async function checkLinkExists(link: string): Promise<boolean> {
  if (!link || link.trim() === "") return false

  try {
    const normalized = normalizeIntuitionLink(link)
    if (!normalized) return false

    const supabase = createClient()
    if (!supabase) return false

    const { data, error } = await supabase.from("meme_tokens").select("id").eq("intuition_link", normalized).limit(1)

    if (error) {
      console.error("[v0] Error checking link:", error)
      return false
    }

    return (data || []).length > 0
  } catch (error) {
    console.error("[v0] Failed to check link:", error)
    return false
  }
}

// Create new token
export async function createTokenInDatabase(token: Omit<MemeToken, "id">): Promise<MemeToken | null> {
  try {
    console.log("[v0] createTokenInDatabase called with:", {
      name: token.name,
      symbol: token.symbol,
      contractAddress: token.contractAddress,
      creator: token.creator,
    })

    const supabase = createClient()
    if (!supabase) {
      console.error("[v0] Supabase client not initialized")
      return null
    }

    console.log("[v0] Supabase client created successfully")

    console.log("[v0] Ensuring user profile exists for creator:", token.creator)
    const profileCreated = await ensureUserProfileExists(token.creator)
    if (!profileCreated) {
      console.error("[v0] Failed to create user profile, cannot create token")
      return null
    }

    const createdAt = token.createdAt || new Date().toISOString()
    console.log("[v0] Using timestamp:", createdAt)

    const insertData = {
      name: token.name,
      symbol: token.symbol,
      image: token.image,
      current_price: token.currentPrice,
      start_price: token.startPrice,
      market_cap: token.marketCap,
      max_supply: Math.floor(token.maxSupply),
      current_supply: Math.floor(token.currentSupply),
      holders: Math.floor(token.holders),
      creator: token.creator,
      intuition_link: token.intuitionLink || null,
      is_alpha: token.isAlpha,
      contract_address: token.contractAddress,
      is_completed: token.isCompleted,
      created_at: createdAt,
      factory_address: token.factory_address || null,
      is_rewind_2025: token.isRewind2025 || null,
    }

    console.log("[v0] Inserting token data:", insertData)

    const { data, error } = await supabase.from("meme_tokens").insert([insertData]).select().single()

    if (error) {
      console.error("[v0] Error creating token in database:", error)
      console.error("[v0] Error details:", {
        message: error.message,
        details: error.details,
        hint: error.hint,
        code: error.code,
      })
      return null
    }

    console.log("[v0] Token inserted successfully:", data)
    const formattedToken = data ? supabaseToToken(data) : null
    console.log("[v0] Formatted token:", formattedToken)
    return formattedToken
  } catch (error) {
    console.error("[v0] Failed to create token (exception):", error)
    if (error instanceof Error) {
      console.error("[v0] Error message:", error.message)
      console.error("[v0] Error stack:", error.stack)
    }
    return null
  }
}

// Update token data in database
export async function updateTokenInDatabase(
  contractAddress: string,
  updates: {
    currentPrice?: number
    currentSupply?: number
    marketCap?: number
    holders?: number
    isCompleted?: boolean
    factory_address?: string
    isRewind2025?: boolean
  },
): Promise<boolean> {
  try {
    const supabase = createClient()
    if (!supabase) {
      console.error("[v0] Supabase client not initialized")
      return false
    }

    // Build the update object with snake_case keys
    const dbUpdates: any = {}
    if (updates.currentPrice !== undefined) dbUpdates.current_price = updates.currentPrice
    if (updates.currentSupply !== undefined) dbUpdates.current_supply = Math.floor(updates.currentSupply)

    if (updates.currentSupply !== undefined) {
      // Auto-calculate market cap using bonding curve formula
      const calculatedMarketCap = calculateMarketCap(updates.currentSupply)
      dbUpdates.market_cap = calculatedMarketCap
    }

    if (updates.holders !== undefined) dbUpdates.holders = Math.floor(updates.holders)
    if (updates.isCompleted !== undefined) dbUpdates.is_completed = updates.isCompleted
    if (updates.factory_address !== undefined) dbUpdates.factory_address = updates.factory_address
    if (updates.isRewind2025 !== undefined) dbUpdates.is_rewind_2025 = updates.isRewind2025

    const { error } = await supabase.from("meme_tokens").update(dbUpdates).eq("contract_address", contractAddress)

    if (error) {
      console.error("[v0] Error updating token:", error)
      return false
    }

    return true
  } catch (error) {
    console.error("[v0] Failed to update token:", error)
    return false
  }
}

// Delete all tokens (admin/migration use)
export async function deleteAllTokens(): Promise<boolean> {
  try {
    const supabase = createClient()
    if (!supabase) {
      console.error("[v0] Supabase client not initialized")
      return false
    }

    // First, get all token contract addresses
    const { data: allTokens } = await supabase.from("meme_tokens").select("contract_address")

    if (!allTokens || allTokens.length === 0) {
      console.log("[v0] No tokens to delete")
      return true
    }

    const tokenAddresses = allTokens.map((t) => t.contract_address)

    // Delete all starred tokens that reference these tokens
    const { error: starredError } = await supabase.from("starred_tokens").delete().in("token_address", tokenAddresses)

    if (starredError) {
      console.error("[v0] Error clearing starred tokens:", starredError)
      // Don't fail the whole operation if starred tokens deletion fails
    }

    // Delete all tokens using neq with a non-existent id to match all rows
    const { error: tokensError } = await supabase
      .from("meme_tokens")
      .delete()
      .neq("id", "00000000-0000-0000-0000-000000000000")

    if (tokensError) {
      console.error("[v0] Error deleting tokens:", tokensError)
      return false
    }

    console.log("[v0] All tokens and starred references deleted successfully")
    return true
  } catch (error) {
    console.error("[v0] Failed to delete tokens:", error)
    return false
  }
}

export async function ensureUserProfileExists(walletAddress: string): Promise<boolean> {
  try {
    const supabase = createClient()
    if (!supabase) {
      console.error("[v0] Supabase client not initialized")
      return false
    }

    // Check if profile already exists
    const { data: existingProfile } = await supabase
      .from("user_profiles")
      .select("wallet_address")
      .eq("wallet_address", walletAddress)
      .single()

    if (existingProfile) {
      console.log("[v0] User profile already exists for:", walletAddress)
      return true
    }

    // Create new profile
    console.log("[v0] Creating user profile for:", walletAddress)
    const { error } = await supabase.from("user_profiles").insert([
      {
        wallet_address: walletAddress,
        display_name: null,
        bio: null,
        profile_image: null,
      },
    ])

    if (error) {
      console.error("[v0] Error creating user profile:", error)
      return false
    }

    console.log("[v0] User profile created successfully")
    return true
  } catch (error) {
    console.error("[v0] Failed to ensure user profile exists:", error)
    return false
  }
}
[V0_FILE]typescript:file="lib/user-holdings.ts"
import { getContract } from "./web3-provider"
import { formatEther, Contract } from "ethers"

// ERC20 ABI for reading balance
const ERC20_ABI = ["function balanceOf(address owner) public view returns (uint256)"]

export async function getUserTokenBalance(tokenAddress: string, userAddress: string): Promise<string> {
  try {
    if (!tokenAddress || !userAddress) return "0"

    const contract = await getContract()
    const signer = await contract.runner

    // Create an ERC20 token instance
    const tokenContract = new Contract(tokenAddress, ERC20_ABI, signer)

    // Get the user's balance
    const balance = await tokenContract.balanceOf(userAddress)

    return formatEther(balance)
  } catch (error) {
    console.error("[v0] Error fetching user token balance:", error)
    return "0"
  }
}
[V0_FILE]typescript:file="lib/user-profiles.ts"
import { createBrowserClient } from "@/lib/supabase/client"

export interface UserProfile {
  wallet_address: string
  display_name?: string
  profile_image?: string
  bio?: string
  created_at?: string
  updated_at?: string
}

export async function getUserProfile(walletAddress: string): Promise<UserProfile | null> {
  if (!walletAddress) return null

  try {
    const supabase = createBrowserClient()
    if (!supabase) {
      console.warn("[v0] Supabase client not initialized - check environment variables")
      return null
    }

    const { data, error } = await supabase
      .from("user_profiles")
      .select("*")
      .eq("wallet_address", walletAddress.toLowerCase())
      .single()

    if (error) {
      if (error.code === "PGRST116") {
        // Profile doesn't exist yet
        return null
      }
      console.error("[v0] Error fetching user profile:", error)
      return null
    }

    return data
  } catch (error) {
    if (error instanceof TypeError && error.message === "Failed to fetch") {
      console.warn("[v0] Network error fetching user profile - Supabase may not be configured")
    } else {
      console.error("[v0] Error fetching user profile:", error)
    }
    return null
  }
}

export async function createOrUpdateUserProfile(profile: UserProfile): Promise<UserProfile> {
  const supabase = createBrowserClient()
  if (!supabase) {
    throw new Error("Supabase client not initialized")
  }

  const profileData = {
    wallet_address: profile.wallet_address.toLowerCase(),
    display_name: profile.display_name,
    profile_image: profile.profile_image,
    bio: profile.bio,
    updated_at: new Date().toISOString(),
  }

  const { data, error } = await supabase
    .from("user_profiles")
    .upsert(profileData, {
      onConflict: "wallet_address",
    })
    .select()
    .single()

  if (error) {
    console.error("[v0] Error creating/updating user profile:", error)
    throw error
  }

  return data
}
[V0_FILE]typescript:file="lib/utils.ts"
import { clsx, type ClassValue } from "clsx"
import { twMerge } from "tailwind-merge"

export function cn(...inputs: ClassValue[]) {
  return twMerge(clsx(inputs))
}

export function formatLargeNumber(num: number): string {
  if (num >= 1_000_000_000) {
    const billions = num / 1_000_000_000
    // If it's a clean billion (like 1B), show without decimal
    if (billions === Math.floor(billions)) {
      return `${Math.floor(billions)}B`
    }
    return `${billions.toFixed(1)}B`
  }
  if (num >= 1_000_000) {
    const millions = num / 1_000_000
    if (millions === Math.floor(millions)) {
      return `${Math.floor(millions)}M`
    }
    return `${millions.toFixed(1)}M`
  }
  if (num >= 1_000) {
    const thousands = num / 1_000
    if (thousands === Math.floor(thousands)) {
      return `${Math.floor(thousands)}K`
    }
    return `${thousands.toFixed(1)}K`
  }
  return num.toString()
}
[V0_FILE]typescript:file="lib/voting.ts"
import { createBrowserClient } from "@supabase/ssr"
import { getContract } from "./web3-provider"
import { parseEther, Contract } from "ethers"

// ERC20 ABI for checking token balance
const ERC20_ABI = ["function balanceOf(address account) public view returns (uint256)"]

// Minimum token holding required to vote (100,000 tokens)
const MIN_TOKEN_HOLDING = 100000

const CREATOR_VOTING_POWER = 20

// Regular voter voting power (equal for all)
const REGULAR_VOTING_POWER = 1.0

function getSupabaseClient() {
  const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL
  const supabaseAnonKey = process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY

  if (!supabaseUrl || !supabaseAnonKey) {
    return null
  }

  return createBrowserClient(supabaseUrl, supabaseAnonKey)
}

export interface VotingProposal {
  id: string
  title: string
  description: string
  token_address: string
  creator_address: string
  status: "active" | "closed"
  yes_votes: number
  no_votes: number
  yes_voting_power: number
  no_voting_power: number
  created_at: string
  ends_at: string | null
  tx_hash: string | null
}

export interface ProposalVote {
  id: string
  proposal_id: string
  voter_address: string
  vote: "yes" | "no"
  voting_power: number
  tx_hash: string | null
  created_at: string
}

export interface WhitelistedAddress {
  id: string
  proposal_id: string
  wallet_address: string
  created_at: string
}

export interface ProposalValidityResult {
  isValid: boolean
  reasons: string[]
  totalVoters: number
  winningPercentage: number
  isTie: boolean
}

// Create a new voting proposal (admin only)
export async function createProposal(
  title: string,
  description: string,
  tokenAddress: string,
  creatorAddress: string,
): Promise<VotingProposal | null> {
  const supabase = getSupabaseClient()
  if (!supabase) return null

  const endsAt = new Date()
  endsAt.setTime(endsAt.getTime() + 72 * 60 * 60 * 1000) // 72 hours in milliseconds

  console.log("[v0] Creating proposal with ends_at:", endsAt.toISOString())

  const { data, error } = await supabase
    .from("voting_proposals")
    .insert({
      title,
      description,
      token_address: tokenAddress.toLowerCase(),
      creator_address: creatorAddress.toLowerCase(),
      ends_at: endsAt.toISOString(),
    })
    .select()
    .single()

  if (error) {
    console.error("Failed to create proposal:", error)
    return null
  }

  console.log("[v0] Created proposal:", data)
  return data
}

// Get all proposals
export async function getAllProposals(): Promise<VotingProposal[]> {
  const supabase = getSupabaseClient()
  if (!supabase) return []

  const { data, error } = await supabase.from("voting_proposals").select("*").order("created_at", { ascending: false })

  if (error) {
    console.error("Failed to fetch proposals:", error)
    return []
  }

  return data || []
}

// Get proposal by ID
export async function getProposalById(proposalId: string): Promise<VotingProposal | null> {
  const supabase = getSupabaseClient()
  if (!supabase) return null

  const { data, error } = await supabase.from("voting_proposals").select("*").eq("id", proposalId).single()

  if (error) {
    console.error("Failed to fetch proposal:", error)
    return null
  }

  return data
}

// Check if user has already voted on a proposal
export async function hasUserVoted(proposalId: string, voterAddress: string): Promise<boolean> {
  const supabase = getSupabaseClient()
  if (!supabase) return false

  const { data } = await supabase
    .from("proposal_votes")
    .select("id")
    .eq("proposal_id", proposalId)
    .eq("voter_address", voterAddress.toLowerCase())
    .single()

  return !!data
}

// Check if user holds enough tokens to vote (100k minimum)
export async function checkTokenHolding(tokenAddress: string, userAddress: string): Promise<boolean> {
  try {
    const contract = await getContract()
    const signer = await contract.runner

    const tokenContract = new Contract(tokenAddress, ERC20_ABI, signer)
    const balance = await tokenContract.balanceOf(userAddress)

    // Convert balance to number (assuming 18 decimals)
    const balanceInTokens = Number(balance) / 1e18

    return balanceInTokens >= MIN_TOKEN_HOLDING
  } catch (error) {
    console.error("Failed to check token holding:", error)
    return false
  }
}

// Check if user is whitelisted for a proposal (20% voting power)
export async function isWhitelisted(proposalId: string, walletAddress: string): Promise<boolean> {
  const supabase = getSupabaseClient()
  if (!supabase) return false

  const { data } = await supabase
    .from("proposal_whitelist")
    .select("id")
    .eq("proposal_id", proposalId)
    .eq("wallet_address", walletAddress.toLowerCase())
    .single()

  return !!data
}

// Add address to whitelist (admin only)
export async function addToWhitelist(proposalId: string, walletAddress: string): Promise<boolean> {
  const supabase = getSupabaseClient()
  if (!supabase) return false

  const { error } = await supabase.from("proposal_whitelist").insert({
    proposal_id: proposalId,
    wallet_address: walletAddress.toLowerCase(),
  })

  if (error) {
    console.error("Failed to add to whitelist:", error)
    return false
  }

  return true
}

// Remove address from whitelist (admin only)
export async function removeFromWhitelist(proposalId: string, walletAddress: string): Promise<boolean> {
  const supabase = getSupabaseClient()
  if (!supabase) return false

  const { error } = await supabase
    .from("proposal_whitelist")
    .delete()
    .eq("proposal_id", proposalId)
    .eq("wallet_address", walletAddress.toLowerCase())

  if (error) {
    console.error("Failed to remove from whitelist:", error)
    return false
  }

  return true
}

// Get whitelist for a proposal
export async function getProposalWhitelist(proposalId: string): Promise<WhitelistedAddress[]> {
  const supabase = getSupabaseClient()
  if (!supabase) return []

  const { data, error } = await supabase.from("proposal_whitelist").select("*").eq("proposal_id", proposalId)

  if (error) {
    console.error("Failed to fetch whitelist:", error)
    return []
  }

  return data || []
}

// Pay voting fee (0.025 TRUST using addComment function)
export async function payVotingFee(tokenAddress: string): Promise<string | null> {
  try {
    const contract = await getContract()

    // Use the addComment function with a vote-related message
    // The contract charges 0.025 TRUST for each comment
    const voteFee = parseEther("0.025")

    const tx = await contract.addComment(tokenAddress, "VOTE_FEE_PAYMENT", {
      value: voteFee,
    })

    const receipt = await tx.wait()
    return receipt?.transactionHash || tx.hash
  } catch (error: any) {
    console.error("Failed to pay voting fee:", error)

    if (error.message?.includes("user rejected")) {
      throw new Error("Transaction rejected by user")
    } else if (error.message?.includes("insufficient funds")) {
      throw new Error("Insufficient TRUST balance to pay voting fee")
    }

    throw error
  }
}

// Cast a vote on a proposal
export async function castVote(
  proposalId: string,
  voterAddress: string,
  vote: "yes" | "no",
  tokenAddress: string,
): Promise<{ success: boolean; error?: string }> {
  const supabase = getSupabaseClient()
  if (!supabase) {
    return { success: false, error: "Database connection failed" }
  }

  const proposal = await getProposalById(proposalId)
  if (!proposal) {
    return { success: false, error: "Proposal not found" }
  }

  if (proposal.status === "closed") {
    return { success: false, error: "This proposal has been closed" }
  }

  if (proposal.ends_at && new Date(proposal.ends_at) < new Date()) {
    return { success: false, error: "Voting period has ended (72 hours)" }
  }

  // Check if user has already voted
  const alreadyVoted = await hasUserVoted(proposalId, voterAddress)
  if (alreadyVoted) {
    return { success: false, error: "You have already voted on this proposal" }
  }

  // Check if user holds enough tokens
  const hasEnoughTokens = await checkTokenHolding(tokenAddress, voterAddress)
  if (!hasEnoughTokens) {
    return { success: false, error: "You must hold at least 100,000 tokens to vote" }
  }

  // Pay the voting fee first
  let txHash: string | null = null
  try {
    txHash = await payVotingFee(tokenAddress)
  } catch (error: any) {
    return { success: false, error: error.message || "Failed to pay voting fee" }
  }

  // Determine voting power (whitelisted creators get 20 votes extra)
  const whitelisted = await isWhitelisted(proposalId, voterAddress)
  const votingPower = whitelisted ? CREATOR_VOTING_POWER : REGULAR_VOTING_POWER

  // Record the vote
  const { error: voteError } = await supabase.from("proposal_votes").insert({
    proposal_id: proposalId,
    voter_address: voterAddress.toLowerCase(),
    vote,
    voting_power: votingPower,
    tx_hash: txHash,
  })

  if (voteError) {
    console.error("Failed to record vote:", voteError)
    return { success: false, error: "Failed to record vote" }
  }

  // Update proposal vote counts
  const { data: currentProposal } = await supabase
    .from("voting_proposals")
    .select("yes_votes, no_votes, yes_voting_power, no_voting_power")
    .eq("id", proposalId)
    .single()

  if (currentProposal) {
    const updates =
      vote === "yes"
        ? {
            yes_votes: (currentProposal.yes_votes || 0) + 1,
            yes_voting_power: (currentProposal.yes_voting_power || 0) + votingPower,
          }
        : {
            no_votes: (currentProposal.no_votes || 0) + 1,
            no_voting_power: (currentProposal.no_voting_power || 0) + votingPower,
          }

    await supabase.from("voting_proposals").update(updates).eq("id", proposalId)
  }

  return { success: true }
}

// Close a proposal (admin only)
export async function closeProposal(proposalId: string): Promise<boolean> {
  const supabase = getSupabaseClient()
  if (!supabase) return false

  const { error } = await supabase.from("voting_proposals").update({ status: "closed" }).eq("id", proposalId)

  if (error) {
    console.error("Failed to close proposal:", error)
    return false
  }

  return true
}

// Get votes for a proposal
export async function getProposalVotes(proposalId: string): Promise<ProposalVote[]> {
  const supabase = getSupabaseClient()
  if (!supabase) return []

  const { data, error } = await supabase
    .from("proposal_votes")
    .select("*")
    .eq("proposal_id", proposalId)
    .order("created_at", { ascending: false })

  if (error) {
    console.error("Failed to fetch votes:", error)
    return []
  }

  return data || []
}

// Check proposal validity
export async function checkProposalValidity(proposal: VotingProposal): Promise<ProposalValidityResult> {
  const totalVoters = proposal.yes_votes + proposal.no_votes
  const totalVotes = totalVoters

  // Calculate percentages
  let yesPercentage = 0
  let noPercentage = 0
  if (totalVotes > 0) {
    yesPercentage = (proposal.yes_votes / totalVotes) * 100
    noPercentage = (proposal.no_votes / totalVotes) * 100
  }

  const isTie = proposal.yes_votes === proposal.no_votes && totalVotes > 0
  const winningPercentage = Math.max(yesPercentage, noPercentage)

  const reasons: string[] = []

  // Condition 1: At least 100 unique voters
  if (totalVoters < 100) {
    reasons.push(`Only ${totalVoters} voters (minimum 100 required)`)
  }

  // Condition 2: No ties
  if (isTie) {
    reasons.push("Proposal ended in a tie")
  }

  // Condition 3: Winning option must have at least 59%
  if (!isTie && winningPercentage < 59) {
    reasons.push(`Winning option only has ${winningPercentage.toFixed(1)}% (minimum 59% required)`)
  }

  const isValid = totalVoters >= 100 && !isTie && winningPercentage >= 59

  return {
    isValid,
    reasons,
    totalVoters,
    winningPercentage,
    isTie,
  }
}
[V0_FILE]typescript:file="lib/web3-provider.ts"
import { BrowserProvider, Contract, formatEther, JsonRpcProvider } from "ethers"
import { CONTRACT_CONFIG } from "./contract-config"
import ABI from "./contract-abi.json"

let provider: BrowserProvider | null = null
let jsonProvider: JsonRpcProvider | null = null
let signer: any = null

let isConnecting = false
let connectionPromise: Promise<string> | null = null

export async function getProvider() {
  if (typeof window === "undefined" || !window.ethereum) {
    throw new Error("MetaMask or Web3 wallet not found")
  }

  if (!provider) {
    provider = new BrowserProvider(window.ethereum)
  }

  return provider
}

export async function getJsonProvider() {
  if (!jsonProvider) {
    jsonProvider = new JsonRpcProvider(CONTRACT_CONFIG.network.rpcUrl, {
      name: CONTRACT_CONFIG.network.name,
      chainId: CONTRACT_CONFIG.chainId,
    })
  }
  return jsonProvider
}

export async function getSigner() {
  if (typeof window === "undefined" || !window.ethereum) {
    throw new Error("MetaMask or Web3 wallet not found")
  }

  const prov = await getProvider()

  if (!signer) {
    signer = await prov.getSigner()
  }

  return signer
}

let contract: Contract | null = null

export async function getContract() {
  const sig = await getSigner()
  // This prevents ethers.js from attempting ENS resolution on networks that don't support it
  const jsonProv = await getJsonProvider()

  // Create a contract with the signer, but attach the json provider for read-only calls
  if (!contract) {
    contract = new Contract(CONTRACT_CONFIG.address, ABI, sig)
  }

  // Override the provider on the contract to use the JSON provider for read operations
  Object.defineProperty(contract, "provider", {
    value: jsonProv,
    writable: true,
    configurable: true,
  })

  return contract
}

export async function switchNetwork() {
  if (typeof window === "undefined" || !window.ethereum) {
    throw new Error("MetaMask or Web3 wallet not found")
  }

  try {
    await window.ethereum.request({
      method: "wallet_switchEthereumChain",
      params: [{ chainId: `0x${CONTRACT_CONFIG.chainId.toString(16)}` }],
    })
  } catch (error: any) {
    if (error.code === 4902) {
      await window.ethereum.request({
        method: "wallet_addEthereumChain",
        params: [
          {
            chainId: `0x${CONTRACT_CONFIG.chainId.toString(16)}`,
            chainName: CONTRACT_CONFIG.network.name,
            rpcUrls: [CONTRACT_CONFIG.network.rpcUrl],
            nativeCurrency: {
              name: CONTRACT_CONFIG.network.currency,
              symbol: CONTRACT_CONFIG.network.currency,
              decimals: 18,
            },
            blockExplorerUrls: [CONTRACT_CONFIG.network.blockExplorer],
          },
        ],
      })
    } else {
      throw error
    }
  }
}

export async function connectWallet() {
  if (typeof window === "undefined") {
    throw new Error("Cannot connect wallet on server side")
  }

  if (!window.ethereum) {
    throw new Error("No Web3 wallet detected. Please install MetaMask or another Web3 wallet.")
  }

  if (isConnecting && connectionPromise) {
    console.log("[v0] Connection already in progress, returning existing promise")
    return connectionPromise
  }

  connectionPromise = (async () => {
    try {
      isConnecting = true

      try {
        await switchNetwork()
      } catch (networkError: any) {
        console.error("[v0] Network switch error:", networkError)
        if (networkError.code === 4001) {
          throw new Error("Network switch cancelled by user")
        }
        throw new Error(`Failed to switch network: ${networkError.message || "Unknown error"}`)
      }

      try {
        const prov = await getProvider()
        const accounts = await prov.send("eth_requestAccounts", [])

        if (!accounts || accounts.length === 0) {
          throw new Error("No accounts found in wallet")
        }

        signer = null
        return accounts[0]
      } catch (accountError: any) {
        console.error("[v0] Account request error:", accountError)
        if (accountError.code === 4001) {
          throw new Error("Connection cancelled by user")
        }
        if (accountError.code === -32002) {
          throw new Error(
            "A wallet connection request is already pending. Please check your wallet extension and complete or cancel the existing request first.",
          )
        }
        throw new Error(`Failed to connect wallet: ${accountError.message || "Unknown error"}`)
      }
    } catch (error: any) {
      console.error("[v0] Failed to connect wallet:", error)
      throw error
    } finally {
      isConnecting = false
      connectionPromise = null
    }
  })()

  connectionPromise.catch((err) => {
    console.error("[v0] Unhandled wallet connection error:", err)
  })

  return connectionPromise
}

export async function getConnectedAddress() {
  if (typeof window === "undefined" || !window.ethereum) {
    return null
  }

  try {
    const prov = await getProvider()
    const accounts = await prov.send("eth_accounts", [])
    return accounts.length > 0 ? accounts[0] : null
  } catch (error) {
    console.error("[v0] Error getting connected address:", error)
    return null
  }
}

export async function getBalance(address: string) {
  const prov = await getJsonProvider() // Use jsonProvider for read-only operations
  const balance = await prov.getBalance(address)
  return formatEther(balance)
}

export async function disconnectWallet() {
  provider = null
  signer = null
  contract = null
  jsonProvider = null

  if (typeof window !== "undefined" && typeof localStorage !== "undefined") {
    localStorage.removeItem("walletConnected")
  }
}

export async function forceNewWalletConnection() {
  // Clear all cached instances first
  provider = null
  signer = null
  contract = null
  jsonProvider = null

  if (typeof window === "undefined" || !window.ethereum) {
    throw new Error("No Web3 wallet detected. Please install MetaMask or another Web3 wallet.")
  }

  // Switch to correct network first
  await switchNetwork()

  // Force MetaMask to show account picker by requesting permissions
  try {
    await window.ethereum.request({
      method: "wallet_requestPermissions",
      params: [{ eth_accounts: {} }],
    })
  } catch (error: any) {
    if (error.code === 4001) {
      throw new Error("Connection cancelled by user")
    }
    // If wallet_requestPermissions fails, continue with normal connection
    console.log("[v0] wallet_requestPermissions not supported, using eth_requestAccounts")
  }

  // Now get the accounts
  const freshProvider = new BrowserProvider(window.ethereum)
  provider = freshProvider
  const accounts = await freshProvider.send("eth_requestAccounts", [])

  if (!accounts || accounts.length === 0) {
    throw new Error("No accounts found in wallet")
  }

  signer = null // Reset signer so it gets recreated with new account
  return accounts[0]
}

export async function forceReconnectWallet() {
  // Clear all cached instances
  provider = null
  signer = null
  contract = null

  // Request accounts again to get the current wallet
  return connectWallet()
}
[V0_FILE]javascript:file="next.config.mjs"
/** @type {import('next').NextConfig} */
const nextConfig = {
  eslint: {
    ignoreDuringBuilds: true,
  },
  typescript: {
    ignoreBuildErrors: true,
  },
  images: {
    unoptimized: true,
  },
}

export default nextConfig
[V0_FILE]json:file="package.json"
{
  "name": "my-v0-project",
  "version": "0.1.0",
  "private": true,
  "scripts": {
    "build": "next build",
    "dev": "next dev",
    "lint": "eslint .",
    "start": "next start"
  },
  "dependencies": {
    "@hookform/resolvers": "^3.10.0",
    "@radix-ui/react-accordion": "1.2.2",
    "@radix-ui/react-alert-dialog": "1.1.4",
    "@radix-ui/react-aspect-ratio": "1.1.1",
    "@radix-ui/react-avatar": "1.1.2",
    "@radix-ui/react-checkbox": "1.1.3",
    "@radix-ui/react-collapsible": "1.1.2",
    "@radix-ui/react-context-menu": "2.2.4",
    "@radix-ui/react-dialog": "1.1.4",
    "@radix-ui/react-dropdown-menu": "2.1.4",
    "@radix-ui/react-hover-card": "1.1.4",
    "@radix-ui/react-label": "2.1.1",
    "@radix-ui/react-menubar": "1.1.4",
    "@radix-ui/react-navigation-menu": "1.2.3",
    "@radix-ui/react-popover": "1.1.4",
    "@radix-ui/react-progress": "1.1.1",
    "@radix-ui/react-radio-group": "1.2.2",
    "@radix-ui/react-scroll-area": "1.2.2",
    "@radix-ui/react-select": "2.1.4",
    "@radix-ui/react-separator": "1.1.1",
    "@radix-ui/react-slider": "1.2.2",
    "@radix-ui/react-slot": "latest",
    "@radix-ui/react-switch": "1.1.2",
    "@radix-ui/react-tabs": "1.1.2",
    "@radix-ui/react-toast": "1.2.4",
    "@radix-ui/react-toggle": "1.1.1",
    "@radix-ui/react-toggle-group": "1.1.1",
    "@radix-ui/react-tooltip": "1.1.6",
    "@supabase/auth-helpers-nextjs": "0.10.0",
    "@supabase/ssr": "0.7.0",
    "@supabase/supabase-js": "latest",
    "autoprefixer": "^10.4.20",
    "class-variance-authority": "^0.7.1",
    "clsx": "^2.1.1",
    "cmdk": "1.0.4",
    "date-fns": "4.1.0",
    "embla-carousel-react": "8.5.1",
    "ethers": "latest",
    "input-otp": "1.4.1",
    "lucide-react": "^0.454.0",
    "next": "15.2.8",
    "next-themes": "latest",
    "react": "^19",
    "react-day-picker": "9.8.0",
    "react-dom": "^19",
    "react-hook-form": "^7.60.0",
    "react-resizable-panels": "^2.1.7",
    "recharts": "latest",
    "sonner": "^1.7.4",
    "tailwind-merge": "^2.5.5",
    "tailwindcss-animate": "^1.0.7",
    "vaul": "^0.9.9",
    "zod": "3.25.76"
  },
  "devDependencies": {
    "@tailwindcss/postcss": "^4.1.9",
    "@types/node": "^22",
    "@types/react": "^19",
    "@types/react-dom": "^19",
    "postcss": "^8.5",
    "tailwindcss": "^4.1.9",
    "tw-animate-css": "1.3.3",
    "typescript": "^5"
  }
}
[V0_FILE]javascript:file="postcss.config.mjs"
/** @type {import('postcss-load-config').Config} */
const config = {
  plugins: {
    '@tailwindcss/postcss': {},
  },
}

export default config
[V0_FILE]sql:file="scripts/001_create_meme_tokens_table.sql"
-- Create meme_tokens table for storing tokens shared across all users
CREATE TABLE IF NOT EXISTS public.meme_tokens (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  name TEXT NOT NULL,
  symbol TEXT NOT NULL,
  image TEXT,
  current_price DECIMAL(20, 10) DEFAULT 0.0001533,
  start_price DECIMAL(20, 10) DEFAULT 0.0001533,
  market_cap DECIMAL(20, 10) DEFAULT 0,
  max_supply BIGINT DEFAULT 1000000000,
  current_supply BIGINT DEFAULT 0,
  holders INTEGER DEFAULT 1,
  creator TEXT NOT NULL,
  intuition_link TEXT,
  is_alpha BOOLEAN DEFAULT true,
  contract_address TEXT,
  created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
  updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
  UNIQUE(intuition_link)
);

-- Enable RLS for security
ALTER TABLE public.meme_tokens ENABLE ROW LEVEL SECURITY;

-- Allow anyone to view all tokens (read-only)
CREATE POLICY "Allow public read access"
  ON public.meme_tokens FOR SELECT
  USING (true);

-- Allow anyone to insert new tokens
CREATE POLICY "Allow anyone to create tokens"
  ON public.meme_tokens FOR INSERT
  WITH CHECK (true);

-- Allow anyone to update their own tokens (based on creator)
CREATE POLICY "Allow users to update their own tokens"
  ON public.meme_tokens FOR UPDATE
  USING (true)
  WITH CHECK (true);

-- Index for faster lookups
CREATE INDEX idx_intuition_link ON public.meme_tokens(intuition_link) WHERE intuition_link IS NOT NULL;
CREATE INDEX idx_creator ON public.meme_tokens(creator);
CREATE INDEX idx_created_at ON public.meme_tokens(created_at DESC);
[V0_FILE]sql:file="scripts/002_clear_testnet_tokens.sql"
-- Delete all existing testnet tokens from the database
DELETE FROM public.meme_tokens;
[V0_FILE]sql:file="scripts/003_create_user_profiles_table.sql"
-- Create user_profiles table for storing user profile information
CREATE TABLE IF NOT EXISTS public.user_profiles (
  wallet_address TEXT PRIMARY KEY,
  display_name TEXT,
  profile_image TEXT,
  bio TEXT,
  created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
  updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
);

-- Enable RLS for security
ALTER TABLE public.user_profiles ENABLE ROW LEVEL SECURITY;

-- Allow anyone to view all profiles (read-only)
CREATE POLICY "Allow public read access to profiles"
  ON public.user_profiles FOR SELECT
  USING (true);

-- Allow users to insert their own profile
CREATE POLICY "Allow users to create their profile"
  ON public.user_profiles FOR INSERT
  WITH CHECK (true);

-- Allow users to update their own profile
CREATE POLICY "Allow users to update their own profile"
  ON public.user_profiles FOR UPDATE
  USING (true)
  WITH CHECK (true);

-- Index for faster lookups
CREATE INDEX idx_wallet_address ON public.user_profiles(wallet_address);
[V0_FILE]sql:file="scripts/004_create_storage_bucket.sql"
-- Create storage bucket for profile images
INSERT INTO storage.buckets (id, name, public)
VALUES ('profile-images', 'profile-images', true)
ON CONFLICT (id) DO NOTHING;

-- Set up storage policies for profile images
CREATE POLICY "Anyone can view profile images"
ON storage.objects FOR SELECT
USING (bucket_id = 'profile-images');

CREATE POLICY "Authenticated users can upload profile images"
ON storage.objects FOR INSERT
WITH CHECK (bucket_id = 'profile-images');

CREATE POLICY "Users can update their own profile images"
ON storage.objects FOR UPDATE
USING (bucket_id = 'profile-images');

CREATE POLICY "Users can delete their own profile images"
ON storage.objects FOR DELETE
USING (bucket_id = 'profile-images');
[V0_FILE]sql:file="scripts/005_add_creator_foreign_key.sql"
-- Add foreign key relationship between meme_tokens and user_profiles
-- This allows us to join and fetch creator profile information

ALTER TABLE public.meme_tokens 
  ADD CONSTRAINT meme_tokens_creator_fkey 
  FOREIGN KEY (creator) 
  REFERENCES public.user_profiles(wallet_address)
  ON DELETE SET NULL
  ON UPDATE CASCADE;

-- Create index for better join performance
CREATE INDEX IF NOT EXISTS idx_meme_tokens_creator ON public.meme_tokens(creator);
[V0_FILE]sql:file="scripts/006_recalculate_market_caps.sql"
-- Recalculate market cap for all existing tokens using the correct formula
-- Market Cap = Current Price × Circulating Supply (700M tokens)
-- This fixes tokens that were created with the old calculation

UPDATE meme_tokens
SET market_cap = current_price * 700000000
WHERE current_supply > 0;

-- For tokens with 0 supply, use initial price
UPDATE meme_tokens
SET market_cap = 0.0001533 * 700000000
WHERE current_supply = 0;
[V0_FILE]sql:file="scripts/007_create_user_points_table.sql"
-- Create user_points table to track trading points
CREATE TABLE IF NOT EXISTS user_points (
  wallet_address TEXT PRIMARY KEY,
  total_buy_volume NUMERIC DEFAULT 0,
  total_sell_volume NUMERIC DEFAULT 0,
  total_volume NUMERIC DEFAULT 0,
  points NUMERIC DEFAULT 0,
  last_updated TIMESTAMP DEFAULT NOW(),
  created_at TIMESTAMP DEFAULT NOW()
);

-- Create index for faster lookups
CREATE INDEX IF NOT EXISTS idx_user_points_wallet ON user_points(wallet_address);
CREATE INDEX IF NOT EXISTS idx_user_points_points ON user_points(points DESC);

-- Enable RLS
ALTER TABLE user_points ENABLE ROW LEVEL SECURITY;

-- Allow anyone to read points (public leaderboard)
CREATE POLICY "Anyone can read user points" ON user_points
  FOR SELECT USING (true);

-- Allow users to update their own points
CREATE POLICY "Users can update their own points" ON user_points
  FOR ALL USING (true);
[V0_FILE]sql:file="scripts/008_add_launch_completed_field.sql"
-- Add is_completed field to track when completeTokenLaunch is called
ALTER TABLE meme_tokens
ADD COLUMN IF NOT EXISTS is_completed BOOLEAN DEFAULT false;

-- Add index for faster queries
CREATE INDEX IF NOT EXISTS idx_meme_tokens_is_completed ON meme_tokens(is_completed);
[V0_FILE]sql:file="scripts/009_create_token_holders_table.sql"
-- Create table to track unique holders per token
CREATE TABLE IF NOT EXISTS public.token_holders (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  token_address TEXT NOT NULL,
  holder_address TEXT NOT NULL,
  balance DECIMAL(20, 10) DEFAULT 0,
  first_buy_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
  last_trade_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
  UNIQUE(token_address, holder_address)
);

-- Enable RLS
ALTER TABLE public.token_holders ENABLE ROW LEVEL SECURITY;

-- Allow public read access
CREATE POLICY "Allow public read access"
  ON public.token_holders FOR SELECT
  USING (true);

-- Allow anyone to insert/update
CREATE POLICY "Allow anyone to update holders"
  ON public.token_holders FOR ALL
  USING (true)
  WITH CHECK (true);

-- Indexes for fast lookups
CREATE INDEX idx_token_holders_token ON public.token_holders(token_address);
CREATE INDEX idx_token_holders_holder ON public.token_holders(holder_address);
[V0_FILE]sql:file="scripts/011_create_starred_tokens_table.sql"
-- Create starred tokens table to track user favorites
CREATE TABLE IF NOT EXISTS public.starred_tokens (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  user_address TEXT NOT NULL,
  token_address TEXT NOT NULL,
  starred_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
  UNIQUE(user_address, token_address)
);

-- Enable RLS
ALTER TABLE public.starred_tokens ENABLE ROW LEVEL SECURITY;

-- Allow users to read their own starred tokens
CREATE POLICY "Users can read their own starred tokens"
  ON public.starred_tokens
  FOR SELECT
  TO public
  USING (true);

-- Allow users to star tokens
CREATE POLICY "Users can star tokens"
  ON public.starred_tokens
  FOR INSERT
  TO public
  WITH CHECK (true);

-- Allow users to unstar tokens
CREATE POLICY "Users can unstar tokens"
  ON public.starred_tokens
  FOR DELETE
  TO public
  USING (true);

-- Create index for faster queries
CREATE INDEX IF NOT EXISTS idx_starred_tokens_user ON public.starred_tokens(user_address);
CREATE INDEX IF NOT EXISTS idx_starred_tokens_token ON public.starred_tokens(token_address);
[V0_FILE]sql:file="scripts/012_clear_all_tokens.sql"
-- Clear all existing token data from the database
-- This prepares the launchpad for a new contract integration

-- Delete all starred tokens
DELETE FROM starred_tokens;

-- Delete all token holders
DELETE FROM token_holders;

-- Delete all user points
DELETE FROM user_points;

-- Delete all meme tokens
DELETE FROM meme_tokens;

-- Optional: Keep user profiles if users are still the same
-- Uncomment the line below if you want to clear user profiles too
-- DELETE FROM user_profiles;
[V0_FILE]sql:file="scripts/013_add_comment_points_column.sql"
-- Add separate tracking for comment points and trading points
ALTER TABLE user_points ADD COLUMN IF NOT EXISTS comment_points DECIMAL DEFAULT 0;
ALTER TABLE user_points ADD COLUMN IF NOT EXISTS trading_points DECIMAL DEFAULT 0;

-- Update existing records to split points into trading and comment
UPDATE user_points 
SET 
  trading_points = points,
  comment_points = 0
WHERE trading_points IS NULL OR comment_points IS NULL;

-- Add comment to explain the new columns
COMMENT ON COLUMN user_points.trading_points IS 'Points earned from trading volume using logarithmic formula';
COMMENT ON COLUMN user_points.comment_points IS 'Points earned from posting comments (0.025 per comment)';
COMMENT ON COLUMN user_points.points IS 'Total points = trading_points + comment_points';
[V0_FILE]sql:file="scripts/014_create_leaderboard_cache.sql"
-- Create table to cache leaderboard data
CREATE TABLE IF NOT EXISTS leaderboard_cache (
  id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
  cache_type text NOT NULL UNIQUE, -- 'top_traders' or 'most_active' - UNIQUE for upserts
  data jsonb NOT NULL,
  last_updated timestamp with time zone DEFAULT NOW(),
  created_at timestamp with time zone DEFAULT NOW()
);

-- Add RLS policies
ALTER TABLE leaderboard_cache ENABLE ROW LEVEL SECURITY;

-- Allow public read access
CREATE POLICY "Allow public read access to leaderboard cache"
ON leaderboard_cache FOR SELECT
TO public
USING (true);

-- Allow anyone to update cache (for refresh mechanism)
CREATE POLICY "Allow cache updates"
ON leaderboard_cache FOR ALL
TO public
USING (true);

-- Create index for faster lookups
CREATE INDEX IF NOT EXISTS idx_leaderboard_cache_type ON leaderboard_cache(cache_type);
[V0_FILE]css:file="styles/globals.css"
@import 'tailwindcss';
@import 'tw-animate-css';

@custom-variant dark (&:is(.dark *));

:root {
  --background: oklch(1 0 0);
  --foreground: oklch(0.145 0 0);
  --card: oklch(1 0 0);
  --card-foreground: oklch(0.145 0 0);
  --popover: oklch(1 0 0);
  --popover-foreground: oklch(0.145 0 0);
  --primary: oklch(0.205 0 0);
  --primary-foreground: oklch(0.985 0 0);
  --secondary: oklch(0.97 0 0);
  --secondary-foreground: oklch(0.205 0 0);
  --muted: oklch(0.97 0 0);
  --muted-foreground: oklch(0.556 0 0);
  --accent: oklch(0.97 0 0);
  --accent-foreground: oklch(0.205 0 0);
  --destructive: oklch(0.577 0.245 27.325);
  --destructive-foreground: oklch(0.577 0.245 27.325);
  --border: oklch(0.922 0 0);
  --input: oklch(0.922 0 0);
  --ring: oklch(0.708 0 0);
  --chart-1: oklch(0.646 0.222 41.116);
  --chart-2: oklch(0.6 0.118 184.704);
  --chart-3: oklch(0.398 0.07 227.392);
  --chart-4: oklch(0.828 0.189 84.429);
  --chart-5: oklch(0.769 0.188 70.08);
  --radius: 0.625rem;
  --sidebar: oklch(0.985 0 0);
  --sidebar-foreground: oklch(0.145 0 0);
  --sidebar-primary: oklch(0.205 0 0);
  --sidebar-primary-foreground: oklch(0.985 0 0);
  --sidebar-accent: oklch(0.97 0 0);
  --sidebar-accent-foreground: oklch(0.205 0 0);
  --sidebar-border: oklch(0.922 0 0);
  --sidebar-ring: oklch(0.708 0 0);
}

.dark {
  --background: oklch(0.145 0 0);
  --foreground: oklch(0.985 0 0);
  --card: oklch(0.145 0 0);
  --card-foreground: oklch(0.985 0 0);
  --popover: oklch(0.145 0 0);
  --popover-foreground: oklch(0.985 0 0);
  --primary: oklch(0.985 0 0);
  --primary-foreground: oklch(0.205 0 0);
  --secondary: oklch(0.269 0 0);
  --secondary-foreground: oklch(0.985 0 0);
  --muted: oklch(0.269 0 0);
  --muted-foreground: oklch(0.708 0 0);
  --accent: oklch(0.269 0 0);
  --accent-foreground: oklch(0.985 0 0);
  --destructive: oklch(0.396 0.141 25.723);
  --destructive-foreground: oklch(0.637 0.237 25.331);
  --border: oklch(0.269 0 0);
  --input: oklch(0.269 0 0);
  --ring: oklch(0.439 0 0);
  --chart-1: oklch(0.488 0.243 264.376);
  --chart-2: oklch(0.696 0.17 162.48);
  --chart-3: oklch(0.769 0.188 70.08);
  --chart-4: oklch(0.627 0.265 303.9);
  --chart-5: oklch(0.645 0.246 16.439);
  --sidebar: oklch(0.205 0 0);
  --sidebar-foreground: oklch(0.985 0 0);
  --sidebar-primary: oklch(0.488 0.243 264.376);
  --sidebar-primary-foreground: oklch(0.985 0 0);
  --sidebar-accent: oklch(0.269 0 0);
  --sidebar-accent-foreground: oklch(0.985 0 0);
  --sidebar-border: oklch(0.269 0 0);
  --sidebar-ring: oklch(0.439 0 0);
}

@theme inline {
  --font-sans: 'Geist', 'Geist Fallback';
  --font-mono: 'Geist Mono', 'Geist Mono Fallback';
  --color-background: var(--background);
  --color-foreground: var(--foreground);
  --color-card: var(--card);
  --color-card-foreground: var(--card-foreground);
  --color-popover: var(--popover);
  --color-popover-foreground: var(--popover-foreground);
  --color-primary: var(--primary);
  --color-primary-foreground: var(--primary-foreground);
  --color-secondary: var(--secondary);
  --color-secondary-foreground: var(--secondary-foreground);
  --color-muted: var(--muted);
  --color-muted-foreground: var(--muted-foreground);
  --color-accent: var(--accent);
  --color-accent-foreground: var(--accent-foreground);
  --color-destructive: var(--destructive);
  --color-destructive-foreground: var(--destructive-foreground);
  --color-border: var(--border);
  --color-input: var(--input);
  --color-ring: var(--ring);
  --color-chart-1: var(--chart-1);
  --color-chart-2: var(--chart-2);
  --color-chart-3: var(--chart-3);
  --color-chart-4: var(--chart-4);
  --color-chart-5: var(--chart-5);
  --radius-sm: calc(var(--radius) - 4px);
  --radius-md: calc(var(--radius) - 2px);
  --radius-lg: var(--radius);
  --radius-xl: calc(var(--radius) + 4px);
  --color-sidebar: var(--sidebar);
  --color-sidebar-foreground: var(--sidebar-foreground);
  --color-sidebar-primary: var(--sidebar-primary);
  --color-sidebar-primary-foreground: var(--sidebar-primary-foreground);
  --color-sidebar-accent: var(--sidebar-accent);
  --color-sidebar-accent-foreground: var(--sidebar-accent-foreground);
  --color-sidebar-border: var(--sidebar-border);
  --color-sidebar-ring: var(--sidebar-ring);
}

@layer base {
  * {
    @apply border-border outline-ring/50;
  }
  body {
    @apply bg-background text-foreground;
  }
}
[V0_FILE]json:file="tsconfig.json"
{
  "compilerOptions": {
    "lib": ["dom", "dom.iterable", "esnext"],
    "allowJs": true,
    "target": "ES6",
    "skipLibCheck": true,
    "strict": true,
    "noEmit": true,
    "esModuleInterop": true,
    "module": "esnext",
    "moduleResolution": "bundler",
    "resolveJsonModule": true,
    "isolatedModules": true,
    "jsx": "preserve",
    "incremental": true,
    "plugins": [
      {
        "name": "next"
      }
    ],
    "paths": {
      "@/*": ["./*"]
    }
  },
  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
  "exclude": ["node_modules"]
}
[V0_FILE]jpg:file="public/ape-strong-meme.jpg" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/git-blob/prj_5BxupdflowLaXxifYegd5x9mAMLh/0ECAK-ym9D58KsSiyE2ChK/public/ape-strong-meme.jpg"
[V0_FILE]png:file="public/apple-icon.png" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/git-blob/prj_5BxupdflowLaXxifYegd5x9mAMLh/IbCKqe8aOyKCr3C9s15usz/public/apple-icon.png"
[V0_FILE]jpg:file="public/cat-coin-meme.jpg" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/git-blob/prj_5BxupdflowLaXxifYegd5x9mAMLh/dG6UtNKstJDsoPcXCVtVkR/public/cat-coin-meme.jpg"
[V0_FILE]jpg:file="public/doge-moon-meme.jpg" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/git-blob/prj_5BxupdflowLaXxifYegd5x9mAMLh/u_T8fmlZd4NQ41FP4Oudcm/public/doge-moon-meme.jpg"
[V0_FILE]png:file="public/icon-dark-32x32.png" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/git-blob/prj_5BxupdflowLaXxifYegd5x9mAMLh/_NLAIkeVwoL6vEzK2uSXmZ/public/icon-dark-32x32.png"
[V0_FILE]png:file="public/icon-light-32x32.png" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/git-blob/prj_5BxupdflowLaXxifYegd5x9mAMLh/DVnRdScnZe8NA9byc6_b4H/public/icon-light-32x32.png"
[V0_FILE]xml:file="public/icon.svg" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/git-blob/prj_5BxupdflowLaXxifYegd5x9mAMLh/l2-w3jDSPuRqpmK6lDq3GH/public/icon.svg"
[V0_FILE]jpg:file="public/meme-token.jpg" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/git-blob/prj_5BxupdflowLaXxifYegd5x9mAMLh/-GM0kaS4iKHiaIXkQ6J_nP/public/meme-token.jpg"
[V0_FILE]jpg:file="public/pepe-frog-wearing-gold-chains-rapper-style-cartoon.jpg" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/git-blob/prj_5BxupdflowLaXxifYegd5x9mAMLh/DXLuT5hG7r4Bsb0wv5huhJ/public/pepe-frog-wearing-gold-chains-rapper-style-cartoon.jpg"
[V0_FILE]jpg:file="public/pepe-rocket-meme.jpg" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/git-blob/prj_5BxupdflowLaXxifYegd5x9mAMLh/b8cXcnLukFHk9a8c32rio-/public/pepe-rocket-meme.jpg"
[V0_FILE]png:file="public/placeholder-logo.png" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/git-blob/prj_5BxupdflowLaXxifYegd5x9mAMLh/1uv3SMJqY6_jxcFCTgTEak/public/placeholder-logo.png"
[V0_FILE]xml:file="public/placeholder-logo.svg" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/git-blob/prj_5BxupdflowLaXxifYegd5x9mAMLh/XB_XF8ESrwbAjotfOd5Wmb/public/placeholder-logo.svg"
[V0_FILE]jpg:file="public/placeholder-user.jpg" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/git-blob/prj_5BxupdflowLaXxifYegd5x9mAMLh/ONejAluG3EJATcwwA61bXn/public/placeholder-user.jpg"
[V0_FILE]jpg:file="public/placeholder.jpg" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/git-blob/prj_5BxupdflowLaXxifYegd5x9mAMLh/BlrBc_c6JuPtjsBHFMcNJn/public/placeholder.jpg"
[V0_FILE]xml:file="public/placeholder.svg" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/git-blob/prj_5BxupdflowLaXxifYegd5x9mAMLh/J0QvC3Vjlpi92ZtRdLC4Mx/public/placeholder.svg"
[V0_FILE]jpg:file="public/shiba-inu-meme.jpg" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/git-blob/prj_5BxupdflowLaXxifYegd5x9mAMLh/ZKPfaXCnr0RgdoF1ssUwG8/public/shiba-inu-meme.jpg"
[V0_FILE]png:file="public/tribe-logo.png" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/git-blob/prj_5BxupdflowLaXxifYegd5x9mAMLh/Us7gOck4TFnpsXVR3EamMI/public/tribe-logo.png"
[V0_FILE]jpg:file="public/wojak-wisdom-meme.jpg" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/git-blob/prj_5BxupdflowLaXxifYegd5x9mAMLh/35kjG0-rvIB-THbsiAuuaO/public/wojak-wisdom-meme.jpg"</article></body></html>