[V0_FILE]typescriptreact:file="components/network-icon.tsx" isMerged="true" import Image from "next/image" interface NetworkIconProps { network: string className?: string } export function NetworkIcon({ network, className = "w-5 h-5" }: NetworkIconProps) { const getNetworkIcon = (network: string) => { switch (network) { case "TRC20": return "https://sjc.microlink.io/pGyF9TjpiUEKgCxQntq3p6rv4UDWDEz9eobjUngJM0byu21C4s95TsmfRh5x_u6XOJcWFtLZ1VbiggDntjZQKA.jpeg" case "ERC20": return "https://cryptologos.cc/logos/ethereum-eth-logo.png?v=040" case "BEP20": return "https://cryptologos.cc/logos/bnb-bnb-logo.png?v=040" case "BEP2": return "https://cryptologos.cc/logos/bitcoin-btc-logo.png?v=040" case "SOLANA": return "https://cryptologos.cc/logos/solana-sol-logo.png?v=040" case "POLYGON": return "https://cryptologos.cc/logos/polygon-matic-logo.png?v=040" default: return null } } const iconUrl = getNetworkIcon(network) if (!iconUrl) return null return (

) } [V0_FILE]typescriptreact:file="components/transaction-status.tsx" isMerged="true" import { CheckCircle2, Loader2 } from "lucide-react" import { Alert, AlertDescription, AlertTitle } from "@/components/ui/alert" import { Button } from "@/components/ui/button" interface TransactionStatusProps { txId: string network: string amount: string address: string onClose: () => void } export function TransactionStatus({ txId, network, amount, address, onClose }: TransactionStatusProps) { const getExplorerUrl = (network: string, txId: string) => { switch (network) { case "TRC20": return `https://tronscan.org/#/transaction/${txId}` case "ERC20": return `https://etherscan.io/tx/${txId}` case "BEP20": return `https://bscscan.com/tx/${txId}` case "BEP2": return `https://explorer.binance.org/tx/${txId}` case "SOLANA": return `https://solscan.io/tx/${txId}` case "POLYGON": return `https://polygonscan.com/tx/${txId}` default: return "" } } return ( Transaction Successful!

Successfully sent {amount} USDT to {address.slice(0, 6)}...{address.slice(-4)} via {network}

Transaction ID: {txId}

) } [V0_FILE]typescriptreact:file="app/not-found.tsx" isMerged="true" "use client" import Link from "next/link" import Image from "next/image" import { motion } from "framer-motion" import { Button } from "@/components/ui/button" import { Card, CardContent } from "@/components/ui/card" import { useEffect, useState } from "react" const backgrounds = [ "https://i.pinimg.com/736x/d4/94/4b/d4944b653288a782ff878eb10f1568f5.jpg", "https://i.pinimg.com/736x/8e/96/f4/8e96f46492b532cf9189055e6bff9d9c.jpg", "https://i.pinimg.com/736x/6a/09/cf/6a09cfeb81eace973d02585f7c0af361.jpg", "https://i.pinimg.com/736x/91/50/c4/9150c4d53b71fb4e77eef56b501780e7.jpg", "https://i.pinimg.com/736x/de/18/f5/de18f5dc6711d339754e3b9971978cdd.jpg", ] export default function NotFound() { const [background, setBackground] = useState("") useEffect(() => { setBackground(backgrounds[Math.floor(Math.random() * backgrounds.length)]) }, []) return (

404

Page Not Found

The page you're looking for doesn't exist or has been moved.

) } [V0_FILE]typescriptreact:file="app/telegram/page.tsx" isMerged="true" "use client" import { useEffect, useState } from "react" import Image from "next/image" import { motion } from "framer-motion" import { Button } from "@/components/ui/button" import { Card, CardContent } from "@/components/ui/card" import { Loader2 } from "lucide-react" interface TelegramPost { id: number text: string date: string } const backgrounds = [ "https://i.pinimg.com/736x/d4/94/4b/d4944b653288a782ff878eb10f1568f5.jpg", "https://i.pinimg.com/736x/8e/96/f4/8e96f46492b532cf9189055e6bff9d9c.jpg", "https://i.pinimg.com/736x/6a/09/cf/6a09cfeb81eace973d02585f7c0af361.jpg", "https://i.pinimg.com/736x/91/50/c4/9150c4d53b71fb4e77eef56b501780e7.jpg", "https://i.pinimg.com/736x/de/18/f5/de18f5dc6711d339754e3b9971978cdd.jpg", ] export default function TelegramPage() { const [posts, setPosts] = useState([]) const [loading, setLoading] = useState(true) const [background, setBackground] = useState("") useEffect(() => { setBackground(backgrounds[Math.floor(Math.random() * backgrounds.length)]) const fetchPosts = async () => { try { const response = await fetch("/api/telegram-posts") const data = await response.json() setPosts(data) } catch (error) { console.error("Failed to fetch posts:", error) } finally { setLoading(false) } } fetchPosts() const interval = setInterval(fetchPosts, 30 * 60 * 1000) // Fetch every 30 minutes return () => clearInterval(interval) }, []) return (

Recent Updates

Latest news and updates from our Telegram channel

{loading ? (

) : posts.length > 0 ? ( posts.map((post) => (

{post.text}

{new Date(post.date).toLocaleDateString()}

)) ) : ( No posts available )}

) } [V0_FILE]css:file="app/globals.css" isMerged="true" @tailwind base; @tailwind components; @tailwind utilities; @layer base { :root { --background: 222.2 84% 4.9%; --foreground: 210 40% 98%; --card: 0 0% 0%; --card-foreground: 210 40% 98%; --popover: 222.2 84% 4.9%; --popover-foreground: 210 40% 98%; --primary: 151 100% 41%; --primary-foreground: 222.2 47.4% 11.2%; --secondary: 217.2 32.6% 17.5%; --secondary-foreground: 210 40% 98%; --muted: 217.2 32.6% 17.5%; --muted-foreground: 215 20.2% 65.1%; --accent: 217.2 32.6% 17.5%; --accent-foreground: 210 40% 98%; --destructive: 0 62.8% 30.6%; --destructive-foreground: 210 40% 98%; --border: 217.2 32.6% 17.5%; --input: 217.2 32.6% 17.5%; --ring: 151 100% 41%; } } @layer utilities { .animate-float { animation: float 6s ease-in-out infinite; } .animate-pulse { animation: pulse 2s infinite; } .animate-gradientBG { animation: gradientBG 3s ease infinite; } .gradient-text { @apply text-transparent bg-clip-text bg-gradient-to-r from-primary to-secondary; background-size: 200% 200%; } } @keyframes float { 0% { transform: translateY(0px) rotate(0deg); } 50% { transform: translateY(-20px) rotate(5deg); } 100% { transform: translateY(0px) rotate(0deg); } } @keyframes pulse { 0% { box-shadow: 0 0 0 0 rgba(0, 211, 127, 0.4); } 70% { box-shadow: 0 0 0 20px rgba(0, 211, 127, 0); } 100% { box-shadow: 0 0 0 0 rgba(0, 211, 127, 0); } } @keyframes gradientBG { 0% { background-position: 0% 50%; } 50% { background-position: 100% 50%; } 100% { background-position: 0% 50%; } } body { @apply bg-background text-foreground min-h-screen overflow-x-hidden; } .glass-card { @apply bg-black/80 backdrop-blur-xl border border-primary/20 shadow-lg shadow-primary/20; } .glass-input { @apply bg-white/5 border-white/10 text-white placeholder-white/30 focus:border-primary/50 focus:ring-primary/50; } @media (max-width: 640px) { .glass-card { @apply p-4; } .gradient-text { font-size: 1.5rem; } } [V0_FILE]typescriptreact:file="app/api/telegram-posts/route.ts" isEdit="true" isQuickEdit="true" isMerged="true" import { NextResponse } from "next/server" const TELEGRAM_BOT_TOKEN = process.env.TELEGRAM_BOT_TOKEN const CHANNEL_ID = process.env.CHANNEL_ID const ADMIN_ID = process.env.ADMIN_ID async function submitUrlsToIndexNow(urls: string[]) { try { // Submit URLs to IndexNow const response = await fetch("https://www.bing.com/indexnow", { method: "POST", headers: { "Content-Type": "application/json", }, body: JSON.stringify({ host: "flashusdtsender.xyz", key: process.env.INDEXNOW_KEY || "flashusdtsenderkey", urlList: urls, }), }) const result = await response.json() return { success: true, message: `URLs submitted for indexing`, result } } catch (error) { console.error("Error submitting to IndexNow:", error) return { success: false, message: "Failed to submit URLs for indexing" } } } export async function GET() { try { const response = await fetch( `https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/getUpdates?chat_id=${CHANNEL_ID}&limit=10`, ) const data = await response.json() if (!data.ok) { throw new Error("Failed to fetch Telegram posts") } const posts = data.result .filter((update: any) => update.channel_post) .map((update: any) => ({ id: update.channel_post.message_id, text: update.channel_post.text, date: new Date(update.channel_post.date * 1000).toISOString(), })) // Automatically submit new posts for indexing const baseUrl = "https://flashusdtsenderdownload.vercel.app/telegram" const urlsToSubmit = posts.map((post: any) => `${baseUrl}#post-${post.id}`) if (urlsToSubmit.length > 0) { await submitUrlsToIndexNow(urlsToSubmit) } return NextResponse.json(posts) } catch (error) { console.error("Error fetching Telegram posts:", error) return NextResponse.json({ error: "Failed to fetch posts" }, { status: 500 }) } } export async function POST(req: Request) { try { const { userId, action } = await req.json() if (userId !== ADMIN_ID) { return NextResponse.json({ error: "Unauthorized" }, { status: 401 }) } if (action === "force_index") { const baseUrl = "https://flashusdtsenderdownload.vercel.app" const urls = [baseUrl, `${baseUrl}/access`, `${baseUrl}/telegram`] const indexingResults = await submitUrlsToIndexNow(urls) return NextResponse.json({ success: true, message: "Indexing initiated", results: indexingResults, }) } return NextResponse.json({ error: "Invalid action" }, { status: 400 }) } catch (error) { console.error("Error processing admin action:", error) return NextResponse.json({ error: "Internal server error" }, { status: 500 }) } } [V0_FILE]typescript:file="pages/api/cron.ts" isMerged="true" import type { NextApiRequest, NextApiResponse } from "next" import { fetchTelegramPosts } from "../../lib/telegram" export default async function handler(req: NextApiRequest, res: NextApiResponse) { if (req.method === "POST") { // Check for the secret to prevent unauthorized access if (req.headers.authorization !== `Bearer ${process.env.CRON_SECRET}`) { return res.status(401).json({ error: "Unauthorized" }) } try { // Fetch and update Telegram posts const posts = await fetchTelegramPosts() // Here you would typically save these posts to your database // For this example, we'll just log them console.log("Fetched Telegram posts:", posts) // You might want to perform additional daily tasks here res.status(200).json({ message: "Daily cron job executed successfully", postsCount: posts.length }) } catch (error) { console.error("Error in daily cron job:", error) res.status(500).json({ error: "Internal server error" }) } } else { res.setHeader("Allow", ["POST"]) res.status(405).end(`Method ${req.method} Not Allowed`) } } [V0_FILE]typescript:file="lib/telegram.ts" isMerged="true" import axios from "axios" export async function fetchTelegramPosts() { const TELEGRAM_BOT_TOKEN = process.env.TELEGRAM_BOT_TOKEN const CHANNEL_ID = process.env.CHANNEL_ID try { const response = await axios.get( `https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/getUpdates?chat_id=${CHANNEL_ID}&limit=10`, ) if (response.data.ok) { return response.data.result .filter((update: any) => update.channel_post) .map((update: any) => ({ id: update.channel_post.message_id, text: update.channel_post.text, date: new Date(update.channel_post.date * 1000).toISOString(), })) } else { throw new Error("Failed to fetch Telegram posts") } } catch (error) { console.error("Error fetching Telegram posts:", error) throw error } } [V0_FILE]typescriptreact:file="vercel.json" isEdit="true" isQuickEdit="true" isMerged="true" { "crons": [ { "path": "/api/cron", "schedule": "0 0 * * *" }, { "path": "/api/cron/indexnow", "schedule": "0 12 * * *" } ], "headers": [ { "source": "/(.*)", "headers": [ { "key": "X-Content-Type-Options", "value": "nosniff" }, { "key": "X-Frame-Options", "value": "DENY" }, { "key": "X-XSS-Protection", "value": "1; mode=block" } ] }, { "source": "/_next/static/(.*)", "headers": [ { "key": "Cache-Control", "value": "public, max-age=31536000, immutable" } ] }, { "source": "/(.*)\\.(jpg|jpeg|png|gif|webp|svg|ico|ttf|woff|woff2)", "headers": [ { "key": "Cache-Control", "value": "public, max-age=31536000, immutable" } ] } ] } [V0_FILE]json:file="package.json" isMerged="true" { "name": "flash-usdt-sender", "version": "1.0.0", "private": true, "scripts": { "dev": "next dev", "build": "next build", "start": "next start", "lint": "next lint" }, "dependencies": { "@vercel/analytics": "^1.4.1", "@vercel/speed-insights": "^1.1.0", "axios": "^1.7.9", "next": "14.2.16", "react": "18.2.0", "react-dom": "18.2.0" }, "devDependencies": { "@types/node": "^20.4.5", "@types/react": "^18.2.17", "@types/react-dom": "^18.2.7", "autoprefixer": "^10.4.14", "eslint": "^8.46.0", "eslint-config-next": "14.2.16", "postcss": "^8.4.27", "tailwindcss": "^3.3.3", "typescript": "^5.1.6" } } [V0_FILE]javascript:file="next.config.js" isFixed="true" isEdit="true" isQuickEdit="true" isMerged="true" const withBundleAnalyzer = require("@next/bundle-analyzer")({ enabled: process.env.ANALYZE === "true", }) /** @type {import('next').NextConfig} */ const nextConfig = { reactStrictMode: true, images: { domains: ["i.ibb.co", "raw.githubusercontent.com", "i.pinimg.com", "cdn.flashusdtsender.xyz"], loader: "custom", loaderFile: "./lib/imageLoader.js", formats: ["image/avif", "image/webp"], }, async headers() { return [ { source: "/(.*)", headers: [ { key: "Cache-Control", value: "public, max-age=31536000, immutable", }, { key: "X-Content-Type-Options", value: "nosniff", }, { key: "X-Frame-Options", value: "DENY", }, { key: "X-XSS-Protection", value: "1; mode=block", }, ], }, { source: "/api/(.*)", headers: [ { key: "Cache-Control", value: "no-store, max-age=0", }, ], }, ] }, webpack: (config, { dev, isServer }) => { if (!dev && !isServer) { // Replace React with Preact in production Object.assign(config.resolve.alias, { "react/jsx-runtime.js": "preact/compat/jsx-runtime", react: "preact/compat", "react-dom/test-utils": "preact/test-utils", "react-dom": "preact/compat", }) // Add bundle optimization config.optimization.minimize = true config.optimization.splitChunks = { chunks: "all", maxInitialRequests: 25, minSize: 20000, } } return config }, experimental: { optimizeFonts: true, optimizeImages: true, optimizeCss: true, scrollRestoration: true, nextScriptWorkers: true, }, compress: true, poweredByHeader: false, productionBrowserSourceMaps: false, swcMinify: true, } module.exports = withBundleAnalyzer(nextConfig) [V0_FILE]typescriptreact:file="app/access/page.tsx" isMerged="true" "use client" import { useState, useEffect, lazy, Suspense } from "react" import Image from "next/image" import { motion, AnimatePresence } from "framer-motion" import { Loader2, CheckCircle, XCircle } from "lucide-react" import Head from "next/head" import { useToast } from "@/components/ui/use-toast" const Button = lazy(() => import("@/components/ui/button").then((mod) => ({ default: mod.Button }))) const Input = lazy(() => import("@/components/ui/input").then((mod) => ({ default: mod.Input }))) const Card = lazy(() => import("@/components/ui/card").then((mod) => ({ default: mod.Card }))) const CardContent = lazy(() => import("@/components/ui/card").then((mod) => ({ default: mod.CardContent }))) const Label = lazy(() => import("@/components/ui/label").then((mod) => ({ default: mod.Label }))) const backgrounds = [ "https://i.pinimg.com/736x/d4/94/4b/d4944b653288a782ff878eb10f1568f5.jpg", "https://i.pinimg.com/736x/8e/96/f4/8e96f46492b532cf9189055e6bff9d9c.jpg", "https://i.pinimg.com/736x/6a/09/cf/6a09cfeb81eace973d02585f7c0af361.jpg", "https://i.pinimg.com/736x/91/50/c4/9150c4d53b71fb4e77eef56b501780e7.jpg", "https://i.pinimg.com/736x/de/18/f5/de18f5dc6711d339754e3b9971978cdd.jpg", ] declare global { interface Window { atlos?: any } } export default function AccessPage() { const [email, setEmail] = useState("") const [isProcessing, setIsProcessing] = useState(false) const [paymentStatus, setPaymentStatus] = useState<"idle" | "success" | "error">("idle") const { toast } = useToast() const [background, setBackground] = useState("") useEffect(() => { setBackground(backgrounds[Math.floor(Math.random() * backgrounds.length)]) }, []) const processPayment = async () => { if (!email) { toast({ variant: "destructive", title: "Error", description: "Please enter your email address first.", }) return } setIsProcessing(true) setPaymentStatus("idle") try { if (typeof window.atlos !== "undefined") { await window.atlos.Pay({ merchantId: "VJ30UOFJMO", orderId: Date.now().toString(), orderAmount: 250, success: () => { setPaymentStatus("success") toast({ title: "Payment Successful", description: "Access key will be delivered to your email.", }) }, error: () => { setPaymentStatus("error") toast({ variant: "destructive", title: "Payment Failed", description: "Please try again or contact support.", }) }, }) } } catch (error) { setPaymentStatus("error") toast({ variant: "destructive", title: "Payment System Error", description: "Please try again later.", }) } finally { setIsProcessing(false) } } return ( <>

Get Access Now

Enter your email to receive your access key after payment.

Email Address setEmail(e.target.value)} className="bg-white/5 border-white/10 text-white" />

{paymentStatus === "idle" && ( )} {paymentStatus === "success" && ( Payment Successful! )} {paymentStatus === "error" && ( Payment Failed. Please try again. )}

What you'll get:

✓ Instant access to Flash USDT Sender
✓ Multi-network support (TRC20, ERC20, etc.)
✓ 24/7 Technical support
✓ Regular updates and improvements

) } [V0_FILE]typescriptreact:file="app/api/indexnow/route.ts" isEdit="true" isMerged="true" import { NextResponse } from "next/server" import { IndexNowKeyManager } from "@/lib/indexnow-key-manager" // Get the IndexNow key from our key manager const INDEXNOW_KEY = IndexNowKeyManager.getKey() export async function GET() { return new NextResponse(INDEXNOW_KEY, { headers: { "Content-Type": "text/plain", "Cache-Control": "no-store, max-age=0", }, }) } export async function POST(req: Request) { try { const { urls } = await req.json() if (!Array.isArray(urls) || urls.length === 0) { return NextResponse.json({ error: "No URLs provided" }, { status: 400 }) } // Submit URLs to multiple search engines const results = await Promise.all([ // Submit to Bing/IndexNow fetch("https://www.bing.com/indexnow", { method: "POST", headers: { "Content-Type": "application/json", }, body: JSON.stringify({ host: "flashusdtsender.xyz", key: INDEXNOW_KEY, urlList: urls, keyLocation: "https://flashusdtsender.xyz/" + INDEXNOW_KEY + ".txt", }), }), // Submit to Yandex fetch("https://yandex.com/indexnow", { method: "POST", headers: { "Content-Type": "application/json", }, body: JSON.stringify({ host: "flashusdtsender.xyz", key: INDEXNOW_KEY, urlList: urls, keyLocation: "https://flashusdtsender.xyz/" + INDEXNOW_KEY + ".txt", }), }), ]) const processedResults = await Promise.all(results.map((r) => r.json())) return NextResponse.json({ success: true, message: "URLs submitted to search engines", results: processedResults, }) } catch (error) { console.error("Error submitting to IndexNow:", error) return NextResponse.json({ error: "Failed to submit URLs" }, { status: 500 }) } } [V0_FILE]typescriptreact:file="lib/indexnow.ts" isMerged="true" /** * Utility function to submit URLs to IndexNow * @param urls Array of URLs to submit * @returns Response from the IndexNow API */ export async function submitToIndexNow(urls: string[]) { try { const response = await fetch("/api/indexnow", { method: "POST", headers: { "Content-Type": "application/json", }, body: JSON.stringify({ urls }), }) return await response.json() } catch (error) { console.error("Error submitting to IndexNow:", error) throw error } } [V0_FILE]typescriptreact:file="app/admin/indexnow/page.tsx" isEdit="true" isQuickEdit="true" isMerged="true" "use client" import { useState } from "react" import { Button } from "@/components/ui/button" import { Input } from "@/components/ui/input" import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card" import { Textarea } from "@/components/ui/textarea" import { submitToIndexNow } from "@/lib/indexnow" import { Loader2 } from "lucide-react" export default function IndexNowAdmin() { const [urls, setUrls] = useState("") const [isSubmitting, setIsSubmitting] = useState(false) const [result, setResult] = useState(null) const [adminKey, setAdminKey] = useState("") const [isAuthenticated, setIsAuthenticated] = useState(false) const handleAuth = () => { // Simple authentication - in a real app, use a more secure method if (adminKey === process.env.ADMIN_ID) { setIsAuthenticated(true) } else { alert("Invalid admin key") } } const handleSubmit = async () => { if (!urls.trim()) { alert("Please enter at least one URL") return } const urlList = urls .split("\n") .map((url) => url.trim()) .filter((url) => url.length > 0) if (urlList.length === 0) { alert("Please enter valid URLs") return } setIsSubmitting(true) try { const response = await submitToIndexNow(urlList) setResult(response) } catch (error) { console.error("Error:", error) setResult({ error: "Failed to submit URLs" }) } finally { setIsSubmitting(false) } } if (!isAuthenticated) { return (

Admin Authentication setAdminKey(e.target.value)} className="glass-input" />

) } return (

IndexNow URL Submission

Quick Actions

Enter URLs to submit to search engines (one per line)

setUrls(e.target.value)}
              placeholder="https://flashusdtsender.xyz/page1
https://flashusdtsender.xyz/page2"
              className="glass-input h-40"
            />
          </div>
          <Button onClick={handleSubmit} disabled={isSubmitting} className="w-full bg-primary text-black">
            {isSubmitting ? (
              <>
                <Loader2 className="mr-2 h-4 w-4 animate-spin" />
                Submitting...
              </>
            ) : (
              "Submit URLs"
            )}
          </Button>

{result && (
            <div className="mt-4 p-4 rounded-md bg-white/10">
              <h3 className="text-white font-semibold mb-2">Result:</h3>
              <pre className="text-gray-300 text-sm overflow-auto">{JSON.stringify(result, null, 2)}</pre>
            </div>
          )}
        </CardContent>
      </Card>
    </div>
  )
}

[V0_FILE]typescriptreact:file="app/[key].txt/route.ts" isEdit="true" isMerged="true"
import { type NextRequest, NextResponse } from "next/server"
import { IndexNowKeyManager } from "@/lib/indexnow-key-manager"

export async function GET(request: NextRequest, { params }: { params: { key: string } }) {
  const { key } = params

// Verify if this is a valid IndexNow key
  const validKey = IndexNowKeyManager.getKey()

if (key === validKey) {
    return new NextResponse(key, {
      headers: {
        "Content-Type": "text/plain",
        "Cache-Control": "public, max-age=86400", // Cache for 24 hours
      },
    })
  }

return new NextResponse("Invalid key", { status: 404 })
}

[V0_FILE]typescript:file="app/lib/indexnow.ts" isQuickEdit="true" isMerged="true"
/**
 * Utility function to submit URLs to IndexNow
 * @param urls Array of URLs to submit
 * @returns Response from the IndexNow API
 */
export async function submitToIndexNow(urls: string[]) {
  try {
    const response = await fetch("/api/indexnow", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
      },
      body: JSON.stringify({ urls }),
    })

return await response.json()
  } catch (error) {
    console.error("Error submitting to IndexNow:", error)
    throw error
  }
}

[V0_FILE]plaintext:file="public/robots.txt" isMerged="true"
User-agent: *
Allow: /

# Sitemaps
Sitemap: https://flashusdtsender.xyz/sitemap.xml

[V0_FILE]typescriptreact:file="app/sitemap.ts" isMerged="true"
import type { MetadataRoute } from "next"

export default function sitemap(): MetadataRoute.Sitemap {
  const baseUrl = "https://flashusdtsender.xyz"

// Get current date for lastModified
  const currentDate = new Date()

// Define all routes with their priorities and change frequencies
  const routes = [
    {
      url: baseUrl,
      lastModified: currentDate,
      changeFrequency: "daily" as const,
      priority: 1.0,
    },
    {
      url: `${baseUrl}/access`,
      lastModified: currentDate,
      changeFrequency: "weekly" as const,
      priority: 0.8,
    },
    {
      url: `${baseUrl}/telegram`,
      lastModified: currentDate,
      changeFrequency: "daily" as const,
      priority: 0.9,
    },
    {
      url: `${baseUrl}/admin/indexnow`,
      lastModified: currentDate,
      changeFrequency: "monthly" as const,
      priority: 0.5,
    },
  ]

return routes
}

[V0_FILE]typescriptreact:file="lib/indexnow-key-manager.ts" isMerged="true"
import fs from "fs"
import path from "path"
import crypto from "crypto"

const KEY_FILE_PATH = path.join(process.cwd(), "indexnow-key.txt")

/**
 * Manages the IndexNow key without relying on environment variables
 */
export class IndexNowKeyManager {
  /**
   * Gets the current IndexNow key, generating a new one if needed
   */
  static getKey(): string {
    try {
      // Try to read existing key
      if (fs.existsSync(KEY_FILE_PATH)) {
        return fs.readFileSync(KEY_FILE_PATH, "utf-8").trim()
      }
    } catch (error) {
      console.error("Error reading IndexNow key:", error)
    }

// Generate and save a new key if none exists
    return this.generateNewKey()
  }

/**
   * Generates a new IndexNow key and saves it
   */
  private static generateNewKey(): string {
    const newKey = crypto.randomBytes(16).toString("hex")

try {
      fs.writeFileSync(KEY_FILE_PATH, newKey)
    } catch (error) {
      console.error("Error saving IndexNow key:", error)
    }

return newKey
  }
}

[V0_FILE]typescriptreact:file="lib/sitemap-submitter.ts" isEdit="true" isQuickEdit="true" isMerged="true"
import { submitToIndexNow } from "./indexnow"

/**
 * Utility to automatically submit sitemaps to search engines
 */
export async function submitSitemapToSearchEngines() {
  const baseUrl = "https://flashusdtsender.xyz"

try {
    // Create a comprehensive list of URLs to submit
    const urlsToSubmit = [
      // Main sitemap
      `${baseUrl}/sitemap.xml`,

// Main pages
      baseUrl,
      `${baseUrl}/access`,
      `${baseUrl}/telegram`,

// Add any new or frequently updated pages here
      // This ensures they get indexed even with the daily limitation
    ]

// Submit all URLs in a single batch
    const result = await submitToIndexNow(urlsToSubmit)

console.log("IndexNow submission completed:", result)

return {
      success: true,
      message: "Sitemap and key pages submitted successfully",
      result,
    }
  } catch (error) {
    console.error("Error submitting sitemap:", error)
    return { success: false, error: "Failed to submit sitemap" }
  }
}

[V0_FILE]typescriptreact:file="app/api/auto-submit/route.ts" isMerged="true"
import { NextResponse } from "next/server"
import { submitSitemapToSearchEngines } from "@/lib/sitemap-submitter"
import { IndexNowKeyManager } from "@/lib/indexnow-key-manager"

export async function GET(request: Request) {
  // Verify the request is authorized
  const url = new URL(request.url)
  const key = url.searchParams.get("key")

if (key !== IndexNowKeyManager.getKey()) {
    return NextResponse.json({ error: "Unauthorized" }, { status: 401 })
  }

try {
    const result = await submitSitemapToSearchEngines()
    return NextResponse.json(result)
  } catch (error) {
    console.error("Error in auto-submit:", error)
    return NextResponse.json({ error: "Failed to auto-submit" }, { status: 500 })
  }
}

[V0_FILE]typescriptreact:file="app/api/cron/indexnow/route.ts" isMerged="true"
import { NextResponse } from "next/server"
import { submitSitemapToSearchEngines } from "@/lib/sitemap-submitter"

export async function POST(req: Request) {
  // Check for the secret to prevent unauthorized access
  if (req.headers.get("authorization") !== `Bearer ${process.env.CRON_SECRET}`) {
    return NextResponse.json({ error: "Unauthorized" }, { status: 401 })
  }

try {
    const result = await submitSitemapToSearchEngines()
    return NextResponse.json({
      success: true,
      message: "IndexNow submission completed",
      result,
    })
  } catch (error) {
    console.error("Error in IndexNow cron job:", error)
    return NextResponse.json({ error: "Failed to run IndexNow submission" }, { status: 500 })
  }
}

[V0_FILE]typescriptreact:file="app/page.tsx" isEdit="true"
"use client"

import type React from "react"

import { useState, useEffect, useCallback, Suspense } from "react"
import { motion, AnimatePresence } from "framer-motion"
import { AlertCircle, Send, Wallet, Lock, Upload, Loader2, ShieldCheck, Globe, Zap, Clock } from "lucide-react"
import Head from "next/head"
import Link from "next/link"
import { useToast } from "@/components/ui/use-toast"

import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { Label } from "@/components/ui/label"
import { RadioGroup, RadioGroupItem } from "@/components/ui/radio-group"
import { Card, CardContent } from "@/components/ui/card"
import { Alert, AlertDescription } from "@/components/ui/alert"
import { Toaster } from "@/components/ui/toaster"
import { NetworkIcon } from "@/components/network-icon"
import { TransactionStatus } from "@/components/transaction-status"
import { LogoImage } from "@/components/logo-image"

// List of supported networks
const NETWORKS = ["TRC20", "ERC20", "BEP20", "BEP2", "SOLANA", "POLYGON"]

// Background options - using WebP format for better performance
const backgrounds = [
  "/backgrounds/crypto-bg-1.webp",
  "/backgrounds/crypto-bg-2.webp",
  "/backgrounds/crypto-bg-3.webp",
  "/backgrounds/crypto-bg-4.webp",
  "/backgrounds/crypto-bg-5.webp",
]

// FAQ data
const faqItems = [
  {
    question: "What is Flash USDT Sender?",
    answer:
      "Flash USDT Sender is a professional platform designed for fast and secure USDT transactions across multiple networks including TRC20, ERC20, BEP20, BEP2, SOLANA, and POLYGON. It simplifies cryptocurrency transfers with an intuitive interface and robust security features.",
  },
  {
    question: "How does Flash USDT Sender work?",
    answer:
      "After authentication, you can enter the recipient's wallet address, specify the amount, select the network, and send your USDT quickly and securely. The platform provides real-time transaction status updates and verification through blockchain explorers.",
  },
  {
    question: "Is Flash USDT Sender secure?",
    answer:
      "Yes, Flash USDT Sender implements enterprise-grade security measures including access key authentication, encrypted connections, and secure wallet integrations. All transactions are verified and recorded on their respective blockchains for complete transparency.",
  },
  {
    question: "What networks are supported?",
    answer:
      "Flash USDT Sender supports multiple networks for maximum flexibility, including TRC20 (TRON), ERC20 (Ethereum), BEP20 (Binance Smart Chain), BEP2 (Binance Chain), SOLANA, and POLYGON. This allows you to choose the most cost-effective network for your transactions.",
  },
  {
    question: "How do I get an access key?",
    answer:
      "You can obtain an access key by visiting our access page or contacting our support team through Telegram. The access key ensures that only authorized users can utilize the platform's advanced features.",
  },
]

// Features data
const features = [
  {
    icon: <ShieldCheck className="h-12 w-12 text-primary" />,
    title: "Secure Transactions",
    description: "Enterprise-grade security protocols protect your transactions and personal information at all times.",
  },
  {
    icon: <Globe className="h-12 w-12 text-primary" />,
    title: "Multi-Network Support",
    description: "Send USDT across multiple networks including TRC20, ERC20, BEP20, BEP2, SOLANA, and POLYGON.",
  },
  {
    icon: <Zap className="h-12 w-12 text-primary" />,
    title: "Lightning Fast",
    description: "Experience near-instant transaction processing with optimized network integration.",
  },
  {
    icon: <Clock className="h-12 w-12 text-primary" />,
    title: "24/7 Availability",
    description: "Our platform is available around the clock for your cryptocurrency transfer needs.",
  },
]

export default function USDTSender() {
  // Hooks
  const { toast } = useToast()

// State variables
  const [isAuthenticated, setIsAuthenticated] = useState(false)
  const [accessKey, setAccessKey] = useState("")
  const [showError, setShowError] = useState(false)
  const [showFaq, setShowFaq] = useState(false)
  const [activeQuestion, setActiveQuestion] = useState<number | null>(null)
  const [isInstallPromptShown, setIsInstallPromptShown] = useState(false)
  const [deferredPrompt, setDeferredPrompt] = useState<any>(null)
  const [isProcessing, setIsProcessing] = useState(false)
  const [transactionStatus, setTransactionStatus] = useState<{
    txId: string
    network: string
    amount: string
    address: string
  } | null>(null)
  const [formData, setFormData] = useState({
    address: "",
    amount: "",
    network: "TRC20",
  })
  const [background, setBackground] = useState("")

// Effects
  useEffect(() => {
    setBackground(backgrounds[Math.floor(Math.random() * backgrounds.length)])

const handleBeforeInstallPrompt = (e: Event) => {
      e.preventDefault()
      setDeferredPrompt(e)
      setIsInstallPromptShown(true)
    }

window.addEventListener("beforeinstallprompt", handleBeforeInstallPrompt)
    return () => window.removeEventListener("beforeinstallprompt", handleBeforeInstallPrompt)
  }, [])

// Handlers
  const handleInstall = async () => {
    if (!deferredPrompt) return
    deferredPrompt.prompt()
    const { outcome } = await deferredPrompt.userChoice
    if (outcome === "accepted") setIsInstallPromptShown(false)
    setDeferredPrompt(null)
  }

const handleAuth = () => {
    if (accessKey === "likhonsheikh") {
      setIsAuthenticated(true)
      setShowError(false)
      toast({
        title: "Authentication Successful",
        description: "Welcome to Flash USDT Sender",
      })
    } else {
      setShowError(true)
    }
  }

const toggleFaq = () => {
    setShowFaq(!showFaq)
  }

const toggleQuestion = (index: number) => {
    if (activeQuestion === index) {
      setActiveQuestion(null)
    } else {
      setActiveQuestion(index)
    }
  }

const generateRandomTxId = useCallback((network: string) => {
    const prefix =
      {
        TRC20: "0x",
        ERC20: "0x",
        BEP20: "0x",
        BEP2: "bnb",
        SOLANA: "",
        POLYGON: "0x",
      }[network] || ""
    const chars = "0123456789abcdef"
    let result = prefix
    for (let i = 0; i < 64; i++) {
      result += chars[Math.floor(Math.random() * chars.length)]
    }
    return result
  }, [])

const handleSubmit = async () => {
    if (!formData.address || !formData.amount || !formData.network) {
      toast({
        variant: "destructive",
        title: "Error",
        description: "Please fill out all fields!",
      })
      return
    }

setIsProcessing(true)
    await new Promise((resolve) => setTimeout(resolve, 2000)) // Simulate transaction
    const txId = generateRandomTxId(formData.network)
    setTransactionStatus({
      txId,
      network: formData.network,
      amount: formData.amount,
      address: formData.address,
    })
    setIsProcessing(false)
  }

const handleFileUpload = (event: React.ChangeEvent<HTMLInputElement>) => {
    const file = event.target.files?.[0]
    if (file) {
      toast({
        title: "Wallet File Uploaded",
        description: `File "${file.name}" has been successfully uploaded.`,
      })
    }
  }

// Loading state for Suspense
  const LoadingFallback = () => (
    <div className="flex justify-center items-center min-h-[200px]">
      <Loader2 className="w-8 h-8 animate-spin text-primary" />
    </div>
  )

return (
    <>
      <Head>
        <script type="application/ld+json">
          {JSON.stringify({
            "@context": "https://schema.org",
            "@type": "SoftwareApplication",
            name: "Flash USDT Sender",
            applicationCategory: "FinancialSoftware",
            operatingSystem: "Web",
            offers: { "@type": "Offer", price: "0", priceCurrency: "USD" },
            description:
              "Flash USDT Sender is a fast and secure platform for USDT transactions across multiple networks.",
            aggregateRating: { "@type": "AggregateRating", ratingValue: "4.8", ratingCount: "1024" },
          })}
        </script>
      </Head>
      <div
        className="fixed inset-0 bg-black/60 z-0"
        style={{
          backgroundImage: `url('${background}')`,
          backgroundSize: "cover",
          backgroundPosition: "center",
          opacity: 0.4,
        }}
      />
      <div className="min-h-screen flex flex-col items-center justify-center p-4 relative">
        <div className="container mx-auto">
          <AnimatePresence>
            {isInstallPromptShown && (
              <motion.div
                initial={{ opacity: 0, y: -50 }}
                animate={{ opacity: 1, y: 0 }}
                exit={{ opacity: 0, y: -50 }}
                transition={{ duration: 0.3 }}
              >
                <Suspense fallback={<Loader2 className="w-6 h-6 animate-spin text-white" />}>
                  <Alert className="mb-4 max-w-md mx-auto glass-card">
                    <Wallet className="h-4 w-4" />
                    <AlertDescription className="flex items-center">
                      Install Flash USDT Sender
                      <Button variant="outline" size="sm" className="ml-2" onClick={handleInstall}>
                        Install
                      </Button>
                    </AlertDescription>
                  </Alert>
                </Suspense>
              </motion.div>
            )}
          </AnimatePresence>

<motion.div
            initial={{ opacity: 0, scale: 0.9 }}
            animate={{ opacity: 1, scale: 1 }}
            transition={{ duration: 0.5 }}
            className="max-w-5xl mx-auto"
          >
            {!isAuthenticated ? (
              <div className="grid md:grid-cols-2 gap-8">
                <Suspense fallback={<LoadingFallback />}>
                  <Card className="w-full glass-card backdrop-blur-lg order-2 md:order-1">
                    <CardContent className="space-y-6 pt-6">
                      <motion.div
                        initial={{ opacity: 0 }}
                        animate={{ opacity: 1 }}
                        transition={{ delay: 0.2 }}
                        className="space-y-6"
                      >
                        <div className="text-center space-y-2">
                          <LogoImage className="animate-float" />
                          <h1 className="text-3xl font-bold text-white">Flash USDT Sender</h1>
                          <p className="text-gray-300">The Ultimate Multi-Network Cryptocurrency Transfer Platform</p>
                        </div>
                        <div className="space-y-2">
                          <Label htmlFor="access-key" className="text-white">
                            Access Key
                          </Label>
                          <div className="relative">
                            <Input
                              id="access-key"
                              type="password"
                              placeholder="Enter your access key"
                              value={accessKey}
                              onChange={(e) => setAccessKey(e.target.value)}
                              onKeyPress={(e) => e.key === "Enter" && handleAuth()}
                              className="glass-input pr-10 rounded-lg border-2 border-white/10 focus:border-primary/50 transition-all duration-300"
                            />
                            <Lock className="absolute right-3 top-3 h-4 w-4 text-white/50" />
                          </div>
                        </div>
                        <Button
                          className="w-full bg-gradient-to-r from-primary/80 to-primary hover:from-primary hover:to-primary/80 text-black font-semibold py-3 px-4 rounded-lg transition-all duration-300 ease-in-out transform hover:scale-105 hover:shadow-lg"
                          onClick={handleAuth}
                        >
                          Authenticate
                        </Button>
                        <AnimatePresence>
                          {showError && (
                            <motion.div
                              initial={{ opacity: 0, y: 20 }}
                              animate={{ opacity: 1, y: 0 }}
                              exit={{ opacity: 0, y: -20 }}
                              transition={{ duration: 0.3 }}
                            >
                              <Alert variant="destructive" className="bg-red-500/20 border-red-500/50">
                                <AlertCircle className="h-4 w-4" />
                                <AlertDescription className="text-white">
                                  Invalid Key! Get a valid access key from{" "}
                                  <a
                                    href="https://t.me/RecentCoders"
                                    target="_blank"
                                    rel="noopener noreferrer"
                                    className="underline hover:text-primary"
                                  >
                                    RecentCoders
                                  </a>
                                  .
                                </AlertDescription>
                              </Alert>
                            </motion.div>
                          )}
                        </AnimatePresence>
                        <Link href="/access" passHref>
                          <Button
                            variant="outline"
                            className="w-full hover:bg-white/10 border border-primary/30 text-primary hover:text-primary/80"
                          >
                            Get Access Key
                          </Button>
                        </Link>
                      </motion.div>
                    </CardContent>
                  </Card>
                </Suspense>

<div className="space-y-6 order-1 md:order-2">
                  <h2 className="text-4xl font-bold text-white mb-6">
                    Professional USDT <span className="text-primary">Transfer Platform</span>
                  </h2>
                  <div className="grid grid-cols-1 sm:grid-cols-2 gap-4">
                    {features.map((feature, index) => (
                      <Card key={index} className="glass-card backdrop-blur-lg">
                        <CardContent className="p-6">
                          <div className="flex flex-col items-center text-center">
                            {feature.icon}
                            <h3 className="mt-4 text-xl font-semibold text-white">{feature.title}</h3>
                            <p className="mt-2 text-gray-400">{feature.description}</p>
                          </div>
                        </CardContent>
                      </Card>
                    ))}
                  </div>

<Card className="glass-card backdrop-blur-lg p-6">
                    <div className="space-y-4">
                      <h3 className="text-2xl font-semibold text-white">Supported Networks</h3>
                      <div className="grid grid-cols-3 sm:grid-cols-6 gap-4">
                        {NETWORKS.map((network) => (
                          <div key={network} className="flex flex-col items-center">
                            <div className="w-12 h-12 relative mb-2">
                              <NetworkIcon network={network} className="w-12 h-12" />
                            </div>
                            <span className="text-gray-300 text-sm">{network}</span>
                          </div>
                        ))}
                      </div>
                    </div>
                  </Card>
                </div>
              </div>
            ) : (
              <Suspense fallback={<LoadingFallback />}>
                <Card className="w-full max-w-md mx-auto glass-card backdrop-blur-lg">
                  <CardContent className="space-y-6 pt-6">
                    <motion.div
                      initial={{ opacity: 0 }}
                      animate={{ opacity: 1 }}
                      transition={{ delay: 0.2 }}
                      className="space-y-6"
                    >
                      <div className="text-center space-y-2">
                        <LogoImage />
                        <h1 className="text-3xl font-bold text-white">Flash USDT Sender</h1>
                      </div>
                      {transactionStatus ? (
                        <TransactionStatus
                          {...transactionStatus}
                          onClose={() => {
                            setTransactionStatus(null)
                            setFormData({ address: "", amount: "", network: "TRC20" })
                          }}
                        />
                      ) : (
                        <>
                          <div className="space-y-2">
                            <Label htmlFor="address" className="text-white">
                              Recipient USDT Address
                            </Label>
                            <Input
                              id="address"
                              placeholder="Enter recipient address"
                              value={formData.address}
                              onChange={(e) => setFormData({ ...formData, address: e.target.value })}
                              className="glass-input rounded-lg border-2 border-white/10 focus:border-primary/50 transition-all duration-300"
                            />
                          </div>
                          <div className="space-y-2">
                            <Label htmlFor="amount" className="text-white">
                              Amount
                            </Label>
                            <Input
                              id="amount"
                              type="number"
                              placeholder="Enter amount"
                              value={formData.amount}
                              onChange={(e) => setFormData({ ...formData, amount: e.target.value })}
                              className="glass-input rounded-lg border-2 border-white/10 focus:border-primary/50 transition-all duration-300"
                            />
                          </div>
                          <div className="space-y-2">
                            <Label className="text-white">Network</Label>
                            <RadioGroup
                              value={formData.network}
                              onValueChange={(value) => setFormData({ ...formData, network: value })}
                              className="grid grid-cols-2 gap-2 sm:grid-cols-3"
                            >
                              {NETWORKS.map((network) => (
                                <motion.div
                                  key={network}
                                  whileHover={{ scale: 1.05 }}
                                  whileTap={{ scale: 0.95 }}
                                  className="flex items-center space-x-2 p-2 rounded-lg border border-white/10 hover:bg-white/5 transition-colors"
                                >
                                  <RadioGroupItem value={network} id={network} className="text-primary" />
                                  <Label
                                    htmlFor={network}
                                    className="text-white cursor-pointer flex items-center gap-2"
                                  >
                                    <NetworkIcon network={network} />
                                    {network}
                                  </Label>
                                </motion.div>
                              ))}
                            </RadioGroup>
                          </div>
                          <div className="space-y-2">
                            <Label htmlFor="wallet-file" className="text-white">
                              Upload Wallet File
                            </Label>
                            <div className="flex items-center space-x-2">
                              <Input
                                id="wallet-file"
                                type="file"
                                className="hidden"
                                onChange={handleFileUpload}
                                accept=".json,.txt"
                              />
                              <Button
                                onClick={() => document.getElementById("wallet-file")?.click()}
                                className="w-full bg-secondary hover:bg-secondary/90 text-white font-semibold py-2 px-4 rounded-lg transition-all duration-300 ease-in-out transform hover:scale-105"
                              >
                                <Upload className="w-5 h-5 mr-2" />
                                Choose File
                              </Button>
                            </div>
                          </div>
                          <Button
                            className="w-full bg-gradient-to-r from-primary/80 to-primary hover:from-primary hover:to-primary/80 text-black font-semibold py-3 px-4 rounded-lg transition-all duration-300 ease-in-out transform hover:scale-105 hover:shadow-lg disabled:opacity-50 disabled:transform-none"
                            onClick={handleSubmit}
                            disabled={isProcessing}
                          >
                            {isProcessing ? (
                              <>
                                <Loader2 className="w-5 h-5 mr-2 animate-spin" />
                                Processing...
                              </>
                            ) : (
                              <>
                                <Send className="w-5 h-5 mr-2" />
                                SEND
                              </>
                            )}
                          </Button>
                        </>
                      )}
                    </motion.div>
                  </CardContent>
                </Card>
              </Suspense>
            )}

{/* FAQ Section */}
            <motion.div
              initial={{ opacity: 0, y: 20 }}
              animate={{ opacity: 1, y: 0 }}
              transition={{ delay: 0.4, duration: 0.5 }}
              className="mt-12 max-w-3xl mx-auto"
            >
              <Card className="glass-card backdrop-blur-lg">
                <CardContent className="p-6">
                  <div className="flex justify-between items-center mb-6">
                    <h2 className="text-2xl font-bold text-white">Frequently Asked Questions</h2>
                    <Button variant="outline" onClick={toggleFaq} className="border-primary/30 text-primary">
                      {showFaq ? "Hide FAQ" : "Show FAQ"}
                    </Button>
                  </div>

<AnimatePresence>
                    {showFaq && (
                      <motion.div
                        initial={{ opacity: 0, height: 0 }}
                        animate={{ opacity: 1, height: "auto" }}
                        exit={{ opacity: 0, height: 0 }}
                        className="space-y-4"
                      >
                        {faqItems.map((item, index) => (
                          <div key={index} className="border-b border-white/10 pb-4 last:border-b-0">
                            <button
                              onClick={() => toggleQuestion(index)}
                              className="flex justify-between items-center w-full text-left text-white font-medium py-2"
                            >
                              <span>{item.question}</span>
                              <span className="text-xl">{activeQuestion === index ? "−" : "+"}</span>
                            </button>
                            <AnimatePresence>
                              {activeQuestion === index && (
                                <motion.div
                                  initial={{ opacity: 0, height: 0 }}
                                  animate={{ opacity: 1, height: "auto" }}
                                  exit={{ opacity: 0, height: 0 }}
                                  transition={{ duration: 0.3 }}
                                  className="text-gray-400 mt-2"
                                >
                                  {item.answer}
                                </motion.div>
                              )}
                            </AnimatePresence>
                          </div>
                        ))}
                      </motion.div>
                    )}
                  </AnimatePresence>
                </CardContent>
              </Card>
            </motion.div>

{/* Testimonials Section */}
            <motion.div
              initial={{ opacity: 0, y: 20 }}
              animate={{ opacity: 1, y: 0 }}
              transition={{ delay: 0.6, duration: 0.5 }}
              className="mt-12 max-w-4xl mx-auto"
            >
              <h2 className="text-2xl font-bold text-white text-center mb-8">What Our Users Say</h2>
              <div className="grid grid-cols-1 md:grid-cols-3 gap-6">
                {[
                  {
                    name: "Alex",
                    role: "Crypto Trader",
                    text: "Flash USDT Sender has been a game-changer for my trading operations. The speed and reliability are unmatched.",
                  },
                  {
                    name: "Maria",
                    role: "Business Owner",
                    text: "Multi-network support makes this tool invaluable. I can always choose the most cost-effective option for my transfers.",
                  },
                  {
                    name: "John",
                    role: "DeFi Enthusiast",
                    text: "The security features give me peace of mind when transferring large amounts. Highly recommended!",
                  },
                ].map((testimonial, i) => (
                  <Card key={i} className="glass-card backdrop-blur-lg">
                    <CardContent className="p-6 text-center">
                      <div className="space-y-4">
                        <div className="w-12 h-12 rounded-full bg-primary/20 flex items-center justify-center mx-auto">
                          <span className="text-primary text-xl font-bold">{testimonial.name.charAt(0)}</span>
                        </div>
                        <div>
                          <h3 className="text-white font-semibold">{testimonial.name}</h3>
                          <p className="text-gray-400 text-sm">{testimonial.role}</p>
                        </div>
                        <p className="text-gray-300 italic">"{testimonial.text}"</p>
                      </div>
                    </CardContent>
                  </Card>
                ))}
              </div>
            </motion.div>

{/* Footer */}
            <motion.footer
              initial={{ opacity: 0 }}
              animate={{ opacity: 1 }}
              transition={{ delay: 0.8, duration: 0.5 }}
              className="mt-12 text-center text-white/70 pb-8"
            >
              <div className="mb-4">
                <Link href="/telegram" className="text-primary hover:underline mx-2">
                  Telegram Updates
                </Link>
                <Link href="/access" className="text-primary hover:underline mx-2">
                  Get Access
                </Link>
                <a
                  href="https://t.me/RecentCoders"
                  target="_blank"
                  rel="noopener noreferrer"
                  className="text-primary hover:underline mx-2"
                >
                  Support
                </a>
              </div>
              <p>© 2025 Flash USDT Sender | The Ultimate Cryptocurrency Transfer Platform</p>
              <p className="text-sm mt-2">Supported networks: TRC20, ERC20, BEP20, BEP2, SOLANA, POLYGON</p>
            </motion.footer>
          </motion.div>
        </div>
        <Toaster />
      </div>
    </>
  )
}

[V0_FILE]typescript:file="lib/imageLoader.js" isEdit="true"
import { cdnConfig } from "./cdn-config"

export default function cloudinaryLoader({ src, width, quality }) {
  // If the image is already in WebP format, use it directly
  if (src.endsWith(".webp")) {
    return src
  }

return cdnConfig.getImageUrl(src, width, quality)
}

[V0_FILE]typescript:file="middleware.ts" isFixed="true" isEdit="true" isQuickEdit="true"
import { NextResponse } from "next/server"
import type { NextRequest } from "next/server"
import { cdnConfig } from "./lib/cdn-config"

export function middleware(request: NextRequest) {
  const response = NextResponse.next()
  const url = request.nextUrl.pathname

// Skip dynamic routes for caching
  if (url.includes("/api/") || url.startsWith("/_next/data/")) {
    return response
  }

// For static assets (with long-term caching)
  if (url.includes("/_next/static/") || url.match(/\.(js|css|woff2?)$/)) {
    response.headers.set("Cache-Control", `public, max-age=${cdnConfig.cacheTTL.static}, stale-while-revalidate=86400`)
  }

// For images (with optimized formats)
  else if (url.match(/\.(jpe?g|png|gif|svg|webp|avif)$/)) {
    response.headers.set("Cache-Control", `public, max-age=${cdnConfig.cacheTTL.images}, stale-while-revalidate=86400`)
  }

// For HTML pages (with shorter cache time)
  else {
    response.headers.set("Cache-Control", `public, max-age=${cdnConfig.cacheTTL.html}, stale-while-revalidate=86400`)
  }

// Add security headers
  response.headers.set("X-Content-Type-Options", "nosniff")
  response.headers.set("X-Frame-Options", "DENY")
  response.headers.set("X-XSS-Protection", "1; mode=block")
  response.headers.set("Referrer-Policy", "strict-origin-when-cross-origin")

// Add content security policy for better security
  response.headers.set(
    "Content-Security-Policy",
    "default-src 'self'; script-src 'self' 'unsafe-inline' https://www.googletagmanager.com https://atlos.io; style-src 'self' 'unsafe-inline'; img-src 'self' data: https: blob:; font-src 'self'; connect-src 'self' https://www.googletagmanager.com;",
  )

return response
}

export const config = {
  matcher: [
    // Apply to all routes except API routes and specific files
    "/((?!api|_next/static|favicon.ico).*)",
  ],
}

[V0_FILE]typescript:file="lib/cdn-config.ts" isEdit="true"
/**
 * CDN configuration for the application
 */
export const cdnConfig = {
  // Base CDN URL for assets
  baseUrl: "https://cdn.flashusdtsender.xyz",

// Image optimization settings
  imageOptimization: {
    quality: 80,
    format: "webp",
    responsive: true,
  },

// Cache TTL settings (in seconds)
  cacheTTL: {
    images: 2592000, // 30 days
    static: 604800, // 7 days
    html: 3600, // 1 hour
  },

// CDN regions
  regions: ["global"],

/**
   * Get optimized image URL
   */
  getImageUrl(src: string, width?: number, quality?: number): string {
    // If already using CDN or is a data URL, return as is
    if (src.startsWith("https://cdn.") || src.startsWith("data:")) return src

// If it's a local file starting with slash, use optimized path
    if (src.startsWith("/")) {
      // If it's already a WebP image, return it as is
      if (src.endsWith(".webp")) return src

// For local images, we'll serve them directly but create WebP versions during build
      return src
    }

// For external images, apply transformations
    if (src.includes("i.ibb.co") || src.includes("i.pinimg.com") || src.includes("raw.githubusercontent.com")) {
      const params = [
        `w_${width || "auto"}`,
        `q_${quality || this.imageOptimization.quality}`,
        `f_${this.imageOptimization.format}`,
      ].join(",")

return `${this.baseUrl}/image/fetch/${params}/${encodeURIComponent(src)}`
    }

return src
  },
}

[V0_FILE]typescriptreact:file="app/layout.tsx" isEdit="true"
import type React from "react"
import type { Metadata, Viewport } from "next"
import { Inter } from "next/font/google"
import Script from "next/script"
import { Analytics } from "@vercel/analytics/react"
import { SpeedInsights } from "@vercel/speed-insights/next"
import "./globals.css"

// Optimize font loading with display swap for better FCP
const inter = Inter({
  subsets: ["latin"],
  display: "swap",
  preload: true,
  fallback: ["system-ui", "sans-serif"],
})

// Focused keyword list for better SEO
const keywordsList =
  "Flash USDT Sender, cryptocurrency transfer platform, USDT transactions, secure crypto transfers, TRC20, ERC20, BEP20, SOLANA, POLYGON, multi-network crypto, fast USDT transfers, crypto wallet, crypto transaction speed, USDT sender software, cryptocurrency software, Tether transactions"

export const metadata: Metadata = {
  metadataBase: new URL("https://flashusdtsender.xyz"),
  title: "Flash USDT Sender - Fast & Secure Multi-Network USDT Transactions",
  description:
    "Professional Flash USDT Sender platform for fast and secure cryptocurrency transfers across TRC20, ERC20, BEP20, SOLANA, and POLYGON networks. The ultimate USDT transfer solution.",
  keywords: keywordsList,
  authors: [{ name: "Flash USDT Sender Team" }],
  creator: "Flash USDT Sender Team",
  publisher: "Flash USDT Sender",
  formatDetection: {
    telephone: false,
    date: false,
    address: false,
    email: false,
  },
  category: "Finance",
  openGraph: {
    type: "website",
    locale: "en_US",
    url: "https://flashusdtsender.xyz",
    title: "Flash USDT Sender - Fast & Secure Multi-Network USDT Transactions",
    description:
      "Professional USDT transfer solution with multi-network support. Fast, secure, and reliable cryptocurrency transactions.",
    siteName: "Flash USDT Sender",
    images: [
      {
        url: "https://cdn.flashusdtsender.xyz/images/flash-usdt-banner.webp",
        width: 1200,
        height: 630,
        alt: "Flash USDT Sender Platform Preview",
      },
    ],
  },
  twitter: {
    card: "summary_large_image",
    title: "Flash USDT Sender - Fast & Secure Multi-Network USDT Transactions",
    description:
      "Professional USDT transfer solution with multi-network support. Fast, secure, and reliable cryptocurrency transactions.",
    images: ["https://cdn.flashusdtsender.xyz/images/flash-usdt-banner.webp"],
    creator: "@flashusdtsender",
    site: "@flashusdtsender",
  },
  alternates: {
    canonical: "https://flashusdtsender.xyz",
    languages: {
      "en-US": "https://flashusdtsender.xyz",
    },
  },
  icons: {
    icon: [{ url: "/icons/favicon.ico" }],
    apple: [{ url: "/icons/apple-touch-icon.png" }],
  },
  manifest: "/manifest.json",
  verification: {
    google: "C2VnESCcx_Gfz0xPMai0SW8SyAZCWce2A9pOaHShF0A",
  },
  robots: {
    index: true,
    follow: true,
    googleBot: {
      index: true,
      follow: true,
      "max-video-preview": -1,
      "max-image-preview": "large",
      "max-snippet": -1,
    },
  },
}

export const viewport: Viewport = {
  width: "device-width",
  initialScale: 1,
  maximumScale: 5,
  userScalable: true,
  themeColor: "#000000",
}

export default function RootLayout({
  children,
}: {
  children: React.ReactNode
}) {
  return (
    <html lang="en" className={`dark ${inter.className}`}>
      <head>
        <meta charSet="UTF-8" />

{/* DNS prefetch and preconnect for performance */}
        <link rel="preconnect" href="https://fonts.gstatic.com" crossOrigin="anonymous" />
        <link rel="dns-prefetch" href="https://fonts.gstatic.com" />
        <link rel="preconnect" href="https://www.googletagmanager.com" crossOrigin="anonymous" />
        <link rel="dns-prefetch" href="https://www.googletagmanager.com" />
        <link rel="preconnect" href="https://cdn.flashusdtsender.xyz" crossOrigin="anonymous" />
        <link rel="dns-prefetch" href="https://cdn.flashusdtsender.xyz" />

{/* Preload critical assets (WebP format for better performance) */}
        <link rel="preload" href="/logo.webp" as="image" type="image/webp" />
        <link rel="preload" href="/backgrounds/crypto-bg-1.webp" as="image" type="image/webp" />

{/* Inline critical CSS */}
        <style
          dangerouslySetInnerHTML={{
            __html: `
            body{background-color:#000;color:#fff}
            .glass-card{background-color:rgba(0,0,0,.8);backdrop-filter:blur(12px);border:1px solid rgba(0,211,127,.2);box-shadow:0 4px 6px -1px rgba(0,211,127,.1)}
          `,
          }}
        />
      </head>
      <body className="min-h-screen bg-background text-foreground">
        <main>{children}</main>
        <Analytics />
        <SpeedInsights />

{/* Load non-critical scripts with proper strategies */}
        <Script id="structured-data" type="application/ld+json" strategy="afterInteractive">
          {`
            {
              "@context": "https://schema.org",
              "@type": "SoftwareApplication",
              "name": "Flash USDT Sender",
              "applicationCategory": "FinanceApplication",
              "operatingSystem": "Web",
              "offers": {
                "@type": "Offer",
                "price": "250",
                "priceCurrency": "USD"
              },
              "description": "Flash USDT Sender is a professional platform for fast and secure USDT transactions across multiple networks including TRC20, ERC20, BEP20, SOLANA, and POLYGON.",
              "aggregateRating": {
                "@type": "AggregateRating",
                "ratingValue": "4.8",
                "ratingCount": "1024"
              }
            }
          `}
        </Script>
        <Script async src="https://atlos.io/packages/app/atlos.js" strategy="lazyOnload" />
        <Script id="google-tag-manager" strategy="afterInteractive">
          {`
            (function(w,d,s,l,i){
              w[l]=w[l]||[];
              w[l].push({'gtm.start': new Date().getTime(), event:'gtm.js'});
              var f=d.getElementsByTagName(s)[0],
                  j=d.createElement(s),
                  dl=l!='dataLayer'?'&l='+l:'';
              j.async=true;
              j.src='https://www.googletagmanager.com/gtm.js?id='+i+dl;
              f.parentNode.insertBefore(j,f);
            })(window,document,'script','dataLayer','GTM-N4PWTDC6');
          `}
        </Script>
        <noscript>
          <iframe
            src="https://www.googletagmanager.com/ns.html?id=GTM-N4PWTDC6"
            height="0"
            width="0"
            style={{ display: "none", visibility: "hidden" }}
          ></iframe>
        </noscript>
      </body>
    </html>
  )
}

[V0_FILE]typescriptreact:file="components/logo-image.tsx" isEdit="true"
"use client"

import { motion } from "framer-motion"
import Image from "next/image"

interface LogoImageProps {
  className?: string
}

export function LogoImage({ className }: LogoImageProps) {
  return (
    <motion.div
      className={`relative w-32 h-32 mx-auto ${className}`}
      initial={{ scale: 0.5, opacity: 0 }}
      animate={{ scale: 1, opacity: 1 }}
      transition={{ duration: 0.5 }}
    >
      <Image src="/logo.webp" alt="USDT Logo" width={128} height={128} priority className="object-contain" />
    </motion.div>
  )
}

[V0_FILE]typescriptreact:file="components/seo-head.tsx"
import Head from "next/head"

interface SEOHeadProps {
  title?: string
  description?: string
  keywords?: string
  ogImage?: string
  ogUrl?: string
}

export function SEOHead({
  title = "Flash USDT Sender - Fast & Secure Multi-Network USDT Transactions",
  description = "Professional USDT transfer platform with multi-network support. Fast, secure, and reliable cryptocurrency transactions.",
  keywords = "Flash USDT Sender, cryptocurrency transfer platform, USDT transactions, secure crypto transfers",
  ogImage = "https://cdn.flashusdtsender.xyz/images/flash-usdt-banner.webp",
  ogUrl = "https://flashusdtsender.xyz",
}: SEOHeadProps) {
  return (
    <Head>
      <title>{title}</title>
      <meta name="description" content={description} />
      <meta name="keywords" content={keywords} />

{/* Open Graph / Facebook */}
      <meta property="og:type" content="website" />
      <meta property="og:url" content={ogUrl} />
      <meta property="og:title" content={title} />
      <meta property="og:description" content={description} />
      <meta property="og:image" content={ogImage} />

{/* Twitter */}
      <meta property="twitter:card" content="summary_large_image" />
      <meta property="twitter:url" content={ogUrl} />
      <meta property="twitter:title" content={title} />
      <meta property="twitter:description" content={description} />
      <meta property="twitter:image" content={ogImage} />

{/* Structured data */}
      <script type="application/ld+json">
        {JSON.stringify({
          "@context": "https://schema.org",
          "@type": "SoftwareApplication",
          name: "Flash USDT Sender",
          applicationCategory: "FinanceApplication",
          operatingSystem: "Web",
          offers: {
            "@type": "Offer",
            price: "250",
            priceCurrency: "USD",
          },
          description: description,
          aggregateRating: {
            "@type": "AggregateRating",
            ratingValue: "4.8",
            ratingCount: "1024",
          },
        })}
      </script>
    </Head>
  )
}

[V0_FILE]json:file="public/manifest.json" isEdit="true"
{
  "name": "Flash USDT Sender - Professional Cryptocurrency Transfer Platform",
  "short_name": "Flash USDT",
  "description": "Fast and secure USDT transactions across multiple networks including TRC20, ERC20, BEP20, BEP2, SOLANA, and POLYGON.",
  "start_url": "/",
  "display": "standalone",
  "background_color": "#000000",
  "theme_color": "#00D37F",
  "orientation": "portrait",
  "scope": "/",
  "lang": "en",
  "dir": "ltr",
  "prefer_related_applications": false,
  "categories": ["finance", "cryptocurrency", "business"],
  "screenshots": [
    {
      "src": "/screenshots/desktop.webp",
      "sizes": "1280x720",
      "type": "image/webp",
      "platform": "wide",
      "label": "Flash USDT Sender Dashboard"
    },
    {
      "src": "/screenshots/mobile.webp",
      "sizes": "720x1280",
      "type": "image/webp",
      "platform": "narrow",
      "label": "Mobile Interface"
    }
  ],
  "shortcuts": [
    {
      "name": "Send USDT",
      "url": "/",
      "description": "Start a new USDT transfer"
    },
    {
      "name": "Telegram Updates",
      "url": "/telegram",
      "description": "View latest updates from our Telegram channel"
    }
  ],
  "icons": [
    {
      "src": "/icons/icon-192.webp",
      "sizes": "192x192",
      "type": "image/webp",
      "purpose": "any maskable"
    },
    {
      "src": "/icons/icon-512.webp",
      "sizes": "512x512",
      "type": "image/webp",
      "purpose": "any maskable"
    }
  ]
}
</article></body></html>