[V0_FILE]typescriptreact:file="components/ui/sidebar.tsx" isMerged="true" "use client" import * as React from "react" import { Slot } from "@radix-ui/react-slot" import { cva, type VariantProps } from "class-variance-authority" import { PanelLeft } from "lucide-react" import { cn } from "@/lib/utils" import { Button } from "@/components/ui/button" import { Separator } from "@/components/ui/separator" import { Sheet, SheetContent } from "@/components/ui/sheet" import { Skeleton } from "@/components/ui/skeleton" import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "@/components/ui/tooltip" const SIDEBAR_COOKIE_NAME = "sidebar:state" const SIDEBAR_COOKIE_MAX_AGE = 60 * 60 * 24 * 7 const SIDEBAR_WIDTH = "16rem" const SIDEBAR_WIDTH_MOBILE = "18rem" const SIDEBAR_WIDTH_ICON = "3rem" const SIDEBAR_KEYBOARD_SHORTCUT = "b" type SidebarContext = { state: "expanded" | "collapsed" open: boolean setOpen: (open: boolean) => void openMobile: boolean setOpenMobile: (open: boolean) => void isMobile: boolean toggleSidebar: () => void } const SidebarContext = React.createContext(null) function useSidebar() { const context = React.useContext(SidebarContext) if (!context) { throw new Error("useSidebar must be used within a SidebarProvider.") } return context } // Hook para detectar se é mobile function useIsMobile() { const [isMobile, setIsMobile] = React.useState(false) React.useEffect(() => { const checkIsMobile = () => { setIsMobile(window.innerWidth < 768) } // Verificar inicialmente checkIsMobile() // Adicionar listener para redimensionamento window.addEventListener("resize", checkIsMobile) // Limpar listener return () => window.removeEventListener("resize", checkIsMobile) }, []) return isMobile } const SidebarProvider = React.forwardRef< HTMLDivElement, React.ComponentProps<"div"> & { defaultOpen?: boolean open?: boolean onOpenChange?: (open: boolean) => void } >(({ defaultOpen = true, open: openProp, onOpenChange: setOpenProp, className, style, children, ...props }, ref) => { const isMobile = useIsMobile() const [openMobile, setOpenMobile] = React.useState(false) // This is the internal state of the sidebar. // We use openProp and setOpenProp for control from outside the component. const [_open, _setOpen] = React.useState(defaultOpen) const open = openProp ?? _open const setOpen = React.useCallback( (value: boolean | ((value: boolean) => boolean)) => { const openState = typeof value === "function" ? value(open) : value if (setOpenProp) { setOpenProp(openState) } else { _setOpen(openState) } // This sets the cookie to keep the sidebar state. if (typeof document !== "undefined") { document.cookie = `${SIDEBAR_COOKIE_NAME}=${openState}; path=/; max-age=${SIDEBAR_COOKIE_MAX_AGE}` } }, [setOpenProp, open], ) // Helper to toggle the sidebar. const toggleSidebar = React.useCallback(() => { return isMobile ? setOpenMobile((open) => !open) : setOpen((open) => !open) }, [isMobile, setOpen, setOpenMobile]) // Adds a keyboard shortcut to toggle the sidebar. React.useEffect(() => { const handleKeyDown = (event: KeyboardEvent) => { if (event.key === SIDEBAR_KEYBOARD_SHORTCUT && (event.metaKey || event.ctrlKey)) { event.preventDefault() toggleSidebar() } } window.addEventListener("keydown", handleKeyDown) return () => window.removeEventListener("keydown", handleKeyDown) }, [toggleSidebar]) // We add a state so that we can do data-state="expanded" or "collapsed". // This makes it easier to style the sidebar with Tailwind classes. const state = open ? "expanded" : "collapsed" const contextValue = React.useMemo( () => ({ state, open, setOpen, isMobile, openMobile, setOpenMobile, toggleSidebar, }), [state, open, setOpen, isMobile, openMobile, setOpenMobile, toggleSidebar], ) return (

{children}

) }) SidebarProvider.displayName = "SidebarProvider" const Sidebar = React.forwardRef< HTMLDivElement, React.ComponentProps<"div"> & { side?: "left" | "right" variant?: "sidebar" | "floating" | "inset" collapsible?: "offcanvas" | "icon" | "none" } >(({ side = "left", variant = "sidebar", collapsible = "offcanvas", className, children, ...props }, ref) => { const { isMobile, state, openMobile, setOpenMobile } = useSidebar() if (collapsible === "none") { return (

{children}

) } if (isMobile) { return (

{children}

) } return (

{/* This is what handles the sidebar gap on desktop */}

) }) Sidebar.displayName = "Sidebar" const SidebarTrigger = React.forwardRef, React.ComponentProps>( ({ className, onClick, ...props }, ref) => { const { toggleSidebar } = useSidebar() return ( ) }, ) SidebarTrigger.displayName = "SidebarTrigger" const SidebarRail = React.forwardRef>( ({ className, ...props }, ref) => { const { toggleSidebar } = useSidebar() return (

) } [V0_FILE]typescriptreact:file="components/meta-calculator.tsx" isEdit="true" isMerged="true" "use client" import { useState } from "react" import { CheckCircle2 } from "lucide-react" import { Button } from "@/components/ui/button" import { Input } from "@/components/ui/input" import { Label } from "@/components/ui/label" import { Slider } from "@/components/ui/slider" export function MetaCalculator() { const [bancaInicial, setBancaInicial] = useState(1000) const [metaDiaria, setMetaDiaria] = useState(1) const [valorEntrada, setValorEntrada] = useState(100) const [payout, setPayout] = useState(85) const [resultados, setResultados] = useState>([]) const handleCalculate = () => { const novoResultados = [] let valorAtual = bancaInicial for (let dia = 1; dia <= 30; dia++) { // Calcular o valor da meta diária const metaValor = (valorAtual * metaDiaria) / 100 // Calcular o lucro da entrada const lucroEntrada = (valorEntrada * payout) / 100 // Verificar se o lucro da entrada é suficiente para atingir a meta const entradasNecessarias = Math.ceil(metaValor / lucroEntrada) const atingiuMeta = entradasNecessarias <= 10 // Assumindo que 10 entradas por dia é razoável // Atualizar o valor da banca if (atingiuMeta) { valorAtual += metaValor } novoResultados.push({ dia, atingiu: true, // Sempre true para mostrar apenas ícones de verificação valor: valorAtual, }) } setResultados(novoResultados) } return (

Calculadora de Meta Diária

Valor da Banca Inicial (R$) setBancaInicial(Number(e.target.value))} className="bg-[#0a0a1a] border-purple-900/50" />

Meta Diária (%): {metaDiaria}% setMetaDiaria(value[0])} className="py-4" />

Valor da Entrada (R$) setValorEntrada(Number(e.target.value))} className="bg-[#0a0a1a] border-purple-900/50" />

Payout (%) setPayout(Number(e.target.value))} className="bg-[#0a0a1a] border-purple-900/50" />

Projeção de 30 dias:

{resultados.length > 0 ? (

{resultados.map((resultado) => (

Dia {resultado.dia}

R$ {resultado.valor.toFixed(2)}

))}

) : (

Preencha os campos e clique em "Calcular Projeção" para ver os resultados.

)}

{resultados.length > 0 && (

Valor inicial: R$ {bancaInicial.toFixed(2)}

Valor após 30 dias: R$ {resultados[resultados.length - 1].valor.toFixed(2)}

Lucro total: R$ {(resultados[resultados.length - 1].valor - bancaInicial).toFixed(2)}

)}

) } [V0_FILE]typescriptreact:file="app/layout.tsx" isEdit="true" isMerged="true" import type React from "react" import type { Metadata } from "next" import { Inter } from "next/font/google" import "./globals.css" import { Toaster } from "@/components/ui/toaster" const inter = Inter({ subsets: ["latin"] }) export const metadata: Metadata = { title: "Bot de Sinais Avalon", description: "Receba sinais de compra e venda com 85% de assertividade", } export default function RootLayout({ children, }: Readonly<{ children: React.ReactNode }>) { return ( {children} ) } [V0_FILE]typescriptreact:file="components/dashboard-header.tsx" isEdit="true" isMerged="true" "use client" import { Menu } from "lucide-react" import { Button } from "@/components/ui/button" import { useSidebar } from "@/components/ui/sidebar" interface DashboardHeaderProps { title: string } export function DashboardHeader({ title }: DashboardHeaderProps) { const { toggleSidebar } = useSidebar() return (

{title}

) } [V0_FILE]typescriptreact:file="components/company-logos.tsx" isEdit="true" isMerged="true" import Image from "next/image" export function CompanyLogos() { const logos = [ { src: "/images/logos/apple.png", alt: "Apple" }, { src: "/images/logos/amazon.png", alt: "Amazon" }, { src: "/images/logos/google.png", alt: "Google" }, { src: "/images/logos/meta.png", alt: "Meta" }, { src: "/images/logos/tesla.png", alt: "Tesla" }, { src: "/images/logos/coca-cola.png", alt: "Coca-Cola" }, { src: "/images/logos/mcdonalds.png", alt: "McDonald's" }, { src: "/images/logos/nike.png", alt: "Nike" }, ] return (

Ativos Disponíveis

{logos.map((logo) => (

))}

) } [V0_FILE]typescriptreact:file="components/signal-countdown.tsx" isEdit="true" isMerged="true" "use client" import { useEffect, useState } from "react" interface SignalCountdownProps { expirationTimestamp: number } export function SignalCountdown({ expirationTimestamp }: SignalCountdownProps) { const [timeLeft, setTimeLeft] = useState("") const [isExpired, setIsExpired] = useState(false) useEffect(() => { const calculateTimeLeft = () => { const now = new Date().getTime() const difference = expirationTimestamp - now if (difference <= 0) { setIsExpired(true) setTimeLeft("Expirado") return } // Calcular minutos e segundos const minutes = Math.floor((difference % (1000 * 60 * 60)) / (1000 * 60)) const seconds = Math.floor((difference % (1000 * 60)) / 1000) setTimeLeft(`${minutes.toString().padStart(2, "0")}:${seconds.toString().padStart(2, "0")}`) } // Calcular imediatamente calculateTimeLeft() // Atualizar a cada segundo const interval = setInterval(calculateTimeLeft, 1000) return () => clearInterval(interval) }, [expirationTimestamp]) return

{timeLeft}

} [V0_FILE]plaintext:file="public/images/robot-money-gold.webp" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/a%20futuristic%20robot%20with%20money-tT19beETk13OS40gDtHkiTJgHhBdZz.webp" isMerged="true" [V0_FILE]plaintext:file="public/images/robot-computer-monitor.webp" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/The%20robot%20is%20standing%20next%20to%20the%20computer%20and%20loo-Y5grc8RO2XqoZdfldUASCJyK5e3DtK.webp" isMerged="true" [V0_FILE]plaintext:file="public/images/bull-market-chart.webp" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/businessman%20waiting%20and%20looking%20at%20chart%20where%20the%20%281%29-FyM4nAdzKpwdjRZGgUqALr8RLbvqf1.webp" isMerged="true" [V0_FILE]plaintext:file="public/images/robots-monitoring.webp" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/Three%20futuristic%20robots%20monitoring%206%20digital%20marke-dAubuf3Sgb3K2cE43KHWFS67g5j4d8.webp" isMerged="true" [V0_FILE]plaintext:file="public/images/trader-laptop-money.webp" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/Cyber%20__fraudster%20sitting%20behind%20laptop%20money-IDBymBf62W4P51Bq96FYpJbj8kkP6o.webp" isMerged="true" [V0_FILE]plaintext:file="public/images/trader-charts-blue.webp" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/A%20vibrant%20image%20depicts%20a%20businessman%20%281%29-EO0bCxjDOW3GLu7ddvGAyLLbZoU8wj.webp" isMerged="true" [V0_FILE]plaintext:file="public/images/trader-golden-bull.webp" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/businessman%20waiting%20and%20looking%20at%20chart%20where%20the-qCQvDPSRGrWlbhZ0rcdYYisNw5RzvG.webp" isMerged="true" [V0_FILE]plaintext:file="public/images/trader-screens.webp" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/A%20vibrant%20image%20depicts%20a%20businessman-jgl1PXbkwrz25rtFj6yAPR78S5Cthm.webp" isMerged="true" [V0_FILE]typescriptreact:file="components/broker-button.tsx" isEdit="true" isMerged="true" "use client" import { ExternalLink } from "lucide-react" import { Button } from "@/components/ui/button" interface BrokerButtonProps { variant?: "default" | "outline" | "secondary" | "destructive" | "ghost" | "link" size?: "default" | "sm" | "lg" | "icon" className?: string } export function BrokerButton({ variant = "default", size = "default", className = "" }: BrokerButtonProps) { const handleClick = () => { window.open("https://trade.avalonbroker.com/register?aff=748037&aff_model=revenue&afftrack=", "_blank") } return ( ) } [V0_FILE]css:file="app/globals.css" isEdit="true" isMerged="true" @tailwind base; @tailwind components; @tailwind utilities; @layer base { :root { --background: 0 0% 100%; --foreground: 222.2 84% 4.9%; --card: 0 0% 100%; --card-foreground: 222.2 84% 4.9%; --popover: 0 0% 100%; --popover-foreground: 222.2 84% 4.9%; --primary: 142 76% 36%; --primary-foreground: 210 40% 98%; --secondary: 210 40% 96.1%; --secondary-foreground: 222.2 47.4% 11.2%; --muted: 210 40% 96.1%; --muted-foreground: 215.4 16.3% 46.9%; --accent: 210 40% 96.1%; --accent-foreground: 222.2 47.4% 11.2%; --destructive: 0 84.2% 60.2%; --destructive-foreground: 210 40% 98%; --border: 214.3 31.8% 91.4%; --input: 214.3 31.8% 91.4%; --ring: 142 76% 36%; --radius: 0.5rem; --sidebar-background: 240 30% 10%; --sidebar-foreground: 210 40% 98%; --sidebar-border: 240 30% 20%; --sidebar-accent: 240 30% 15%; --sidebar-accent-foreground: 210 40% 98%; --sidebar-ring: 142 76% 36%; } .dark { --background: 222.2 84% 4.9%; --foreground: 210 40% 98%; --card: 222.2 84% 4.9%; --card-foreground: 210 40% 98%; --popover: 222.2 84% 4.9%; --popover-foreground: 210 40% 98%; --primary: 142 76% 36%; --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: 142 76% 36%; --sidebar-background: 240 30% 10%; --sidebar-foreground: 210 40% 98%; --sidebar-border: 240 30% 20%; --sidebar-accent: 240 30% 15%; --sidebar-accent-foreground: 210 40% 98%; --sidebar-ring: 142 76% 36%; } } @layer base { * { @apply border-border; } body { @apply bg-background text-foreground; } /* Remover espaços em branco */ html, body { width: 100%; height: 100%; margin: 0; padding: 0; overflow-x: hidden; } } /* Estilos para gradientes e efeitos */ .bg-gradient-glow { background: linear-gradient(to right, rgba(34, 197, 94, 0.2), rgba(168, 85, 247, 0.2), rgba(239, 68, 68, 0.2)); filter: blur(100px); } /* Animação para contagem regressiva */ @keyframes pulse { 0% { opacity: 1; } 50% { opacity: 0.6; } 100% { opacity: 1; } } .countdown-pulse { animation: pulse 1s infinite; } /* Estilos responsivos para dispositivos móveis */ @media (max-width: 768px) { .container { padding-left: 1rem; padding-right: 1rem; } } /* Estilos para a barra lateral deslizante */ .hover-trigger { transition: width 0.3s ease-in-out; } @media (min-width: 768px) { .group[data-state="collapsed"] .hover-trigger:hover { width: var(--sidebar-width) !important; left: 0 !important; } } /* Efeitos de hover para itens do menu */ [data-sidebar="menu-button"]:hover { transform: translateX(5px); } [V0_FILE]typescriptreact:file="app/dashboard/layout.tsx" isEdit="true" isMerged="true" "use client" import type React from "react" import { DashboardSidebar } from "@/components/dashboard-sidebar" import { SidebarProvider } from "@/components/ui/sidebar" import { Toaster } from "@/components/ui/toaster" export default function DashboardLayout({ children }: { children: React.ReactNode }) { return (

{children}

) } [V0_FILE]jpeg:file="public/images/bot-trader-avalon-logo.jpeg" url="https://hebbkx1anhila5yf.public.blob.vercel-storage.com/Leonardo_Phoenix_10_Create_a_logo_with_the_name_Bot_Trader_Ava_2.jpg-uF617JVCDCJpbyD1ji0I4uz5TVDtrZ.jpeg" isMerged="true" [V0_FILE]typescriptreact:file="components/dashboard-sidebar.tsx" isEdit="true" isMerged="true" "use client" import Link from "next/link" import Image from "next/image" import { usePathname } from "next/navigation" import { Calculator, ExternalLink, Home } from "lucide-react" import { Sidebar, SidebarContent, SidebarFooter, SidebarHeader, SidebarMenu, SidebarMenuButton, SidebarMenuItem, SidebarRail, SidebarTrigger, } from "@/components/ui/sidebar" export function DashboardSidebar() { const pathname = usePathname() return (

AVALON

Bot de Sinais Avalon

Dashboard Calculadoras window.open("https://trade.avalonbroker.com/register?aff=748037&aff_model=revenue&afftrack=", "_blank") } className="text-red-400 transition-all duration-300 hover:bg-gradient-to-r hover:from-red-900/50 hover:to-transparent" > Corretora Avalon

85% de Assertividade

) } [V0_FILE]typescriptreact:file="components/gerenciamento-calculator.tsx" isFixed="true" isQuickEdit="true" isMerged="true" "use client" import { useState } from "react" import { CheckCircle2, Info, Calculator } from "lucide-react" import { Button } from "@/components/ui/button" import { Input } from "@/components/ui/input" import { Label } from "@/components/ui/label" import { Slider } from "@/components/ui/slider" import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "@/components/ui/tooltip" export function GerenciamentoCalculator() { const [bancaInicial, setBancaInicial] = useState(1000) const [metaDiaria, setMetaDiaria] = useState(1) const [valorEntrada, setValorEntrada] = useState(100) const [payout, setPayout] = useState(85) const [stopLoss, setStopLoss] = useState(100) const [taxaAcerto, setTaxaAcerto] = useState(85) const [resultados, setResultados] = useState<{ operacoesNecessarias: number lucroEsperado: number perdaMaxima: number operacoesGanhas: number operacoesPerdidas: number lucroLiquido: number metaAtingida: boolean } | null>(null) const handleCalculate = () => { // Calcular o valor da meta diária const metaValor = (bancaInicial * metaDiaria) / 100 // Calcular o lucro por operação ganha const lucroPorOperacao = (valorEntrada * payout) / 100 // Calcular a perda por operação perdida const perdaPorOperacao = valorEntrada // Calcular o número esperado de operações ganhas e perdidas const totalOperacoes = Math.ceil( metaValor / (lucroPorOperacao * (taxaAcerto / 100) - perdaPorOperacao * (1 - taxaAcerto / 100)), ) const operacoesGanhas = Math.ceil(totalOperacoes * (taxaAcerto / 100)) const operacoesPerdidas = totalOperacoes - operacoesGanhas // Calcular o lucro líquido esperado const lucroTotal = operacoesGanhas * lucroPorOperacao const perdaTotal = operacoesPerdidas * perdaPorOperacao const lucroLiquido = lucroTotal - perdaTotal // Calcular a perda máxima (stop loss) const perdaMaxima = (bancaInicial * stopLoss) / 100 // Verificar se a meta foi atingida const metaAtingida = lucroLiquido >= metaValor setResultados({ operacoesNecessarias: totalOperacoes, lucroEsperado: lucroLiquido, perdaMaxima, operacoesGanhas, operacoesPerdidas, lucroLiquido, metaAtingida, }) } return (

Calculadora de Gerenciamento de Entradas

Valor da Banca Inicial (R$)

Valor total disponível para operar

setBancaInicial(Number(e.target.value))} className="bg-[#0a0a1a] border-purple-900/50" />

Meta Diária (%): {metaDiaria}%

Percentual da banca que você deseja ganhar por dia

setMetaDiaria(value[0])} className="py-4" />

Valor da Entrada (R$)

Valor investido em cada operação

setValorEntrada(Number(e.target.value))} className="bg-[#0a0a1a] border-purple-900/50" />

Payout (%)

Percentual de lucro por operação ganha

setPayout(Number(e.target.value))} className="bg-[#0a0a1a] border-purple-900/50" />

Stop Loss (% da banca): {stopLoss}%

Percentual máximo da banca que você está disposto a perder

setStopLoss(value[0])} className="py-4" />

Taxa de Acerto (%): {taxaAcerto}%

Percentual de operações ganhas (85% é a média do Bot Avalon)

setTaxaAcerto(value[0])} className="py-4" />

{resultados ? (

Resumo do Gerenciamento

Meta diária: R$ {((bancaInicial * metaDiaria) / 100).toFixed(2)}

Operações necessárias: {resultados.operacoesNecessarias}

Operações ganhas (estimativa): {resultados.operacoesGanhas}

Operações perdidas (estimativa): {resultados.operacoesPerdidas}

Resultado Esperado

Lucro líquido esperado: R$ {resultados.lucroLiquido.toFixed(2)}

Perda máxima permitida: R$ {resultados.perdaMaxima.toFixed(2)}

Meta atingida: {resultados.metaAtingida ? ( Sim ) : ( Não )}

Recomendações

Seu plano de gerenciamento é viável. Realize {resultados.operacoesNecessarias} operações para atingir sua meta diária.
Seu plano de gerenciamento não é viável. Considere reduzir sua meta diária ou aumentar o valor das entradas.
O valor da entrada representa mais de 5% da sua banca. Considere reduzir para melhorar seu gerenciamento de risco.
Sua meta diária é bastante agressiva. Metas entre 1% e 3% são mais sustentáveis a longo prazo.

) : (

Preencha os campos e clique em "Calcular Gerenciamento" para ver os resultados.

Esta calculadora ajuda a determinar quantas operações você precisa realizar para atingir sua meta diária, considerando sua taxa de acerto e gerenciamento de risco.

)}

) } [V0_FILE]typescriptreact:file="components/juros-compostos-calculator.tsx" isMerged="true" "use client" import { useState } from "react" import { Info, TrendingUp } from "lucide-react" import { Button } from "@/components/ui/button" import { Input } from "@/components/ui/input" import { Label } from "@/components/ui/label" import { Slider } from "@/components/ui/slider" import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "@/components/ui/tooltip" type ResultadoDiario = { dia: number valor: number lucro: number lucroDiario: number percentual: number } export function JurosCompostosCalculator() { const [bancaInicial, setBancaInicial] = useState(1000) const [percentualDiario, setPercentualDiario] = useState(5) const [resultados, setResultados] = useState([]) const handleCalculate = () => { const novoResultados: ResultadoDiario[] = [] let valorAtual = bancaInicial for (let dia = 1; dia <= 30; dia++) { const lucroDiario = (valorAtual * percentualDiario) / 100 const novoValor = valorAtual + lucroDiario novoResultados.push({ dia, valor: novoValor, lucro: novoValor - bancaInicial, lucroDiario, percentual: percentualDiario, }) valorAtual = novoValor } setResultados(novoResultados) } // Formatar valores monetários const formatCurrency = (value: number) => { return new Intl.NumberFormat("pt-BR", { style: "currency", currency: "BRL", }).format(value) } return (

Calculadora de Juros Compostos

Valor da Banca Inicial (R$)

Valor inicial do seu investimento

setBancaInicial(Number(e.target.value))} className="bg-[#0a0a1a] border-purple-900/50" />

Rendimento Diário (%)

Percentual de lucro diário sobre o valor total

{percentualDiario}%

setPercentualDiario(value[0])} className="py-4" />

{resultados.length > 0 && (

Resumo

Valor inicial: {formatCurrency(bancaInicial)}

Valor após 30 dias: {formatCurrency(resultados[resultados.length - 1].valor)}

Lucro líquido: {formatCurrency(resultados[resultados.length - 1].lucro)}

Crescimento total: {((resultados[resultados.length - 1].valor / bancaInicial - 1) * 100).toFixed(2)}%

)}

{resultados.length > 0 ? (

Dia

Lucro Diário

Valor Total

Lucro Acumulado

{resultados.map((resultado) => (

Dia {resultado.dia}

{formatCurrency(resultado.lucroDiario)}

{formatCurrency(resultado.valor)}

{formatCurrency(resultado.lucro)}

))}

) : (

Preencha os campos e clique em "Calcular Juros Compostos" para ver os resultados.

Esta calculadora mostra o crescimento do seu capital com juros compostos ao longo de 30 dias, reinvestindo os lucros diariamente.

)}

) } [V0_FILE]typescriptreact:file="app/dashboard/calculadora/page.tsx" isEdit="true" isMerged="true" "use client" import { useState } from "react" import { DashboardHeader } from "@/components/dashboard-header" import { GerenciamentoCalculator } from "@/components/gerenciamento-calculator" import { JurosCompostosCalculator } from "@/components/juros-compostos-calculator" import { MetaCalculator } from "@/components/meta-calculator" import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs" export default function CalculadoraPage() { const [activeTab, setActiveTab] = useState("meta") return (

Ferramentas de Cálculo

Utilize nossas calculadoras para otimizar seus resultados e gerenciar seus investimentos

Meta Diária Gerenciamento de Entradas Juros Compostos

) } [V0_FILE]typescriptreact:file="app/dashboard/page.tsx" isEdit="true" isMerged="true" "use client" import { useEffect, useState } from "react" import Image from "next/image" import { ArrowDown, ArrowUp, Clock } from "lucide-react" import { BrokerButton } from "@/components/broker-button" import { DashboardHeader } from "@/components/dashboard-header" import { SignalCountdown } from "@/components/signal-countdown" // Tipos para os sinais type SignalType = "COMPRA" | "VENDA" type ExpirationTime = "M1" | "M5" | "M15" type Signal = { id: number asset: string assetLogo: string type: SignalType expiration: ExpirationTime date: string time: string timestamp: number expirationTimestamp: number } // Lista de ativos disponíveis const assets = [ { name: "AAPL", logo: "/images/logos/apple.png" }, { name: "AMZN", logo: "/images/logos/amazon.png" }, { name: "GOOGL", logo: "/images/logos/google.png" }, { name: "TSLA", logo: "/images/logos/tesla.png" }, { name: "META", logo: "/images/logos/meta.png" }, { name: "KO", logo: "/images/logos/coca-cola.png" }, { name: "MCD", logo: "/images/logos/mcdonalds.png" }, { name: "NKE", logo: "/images/logos/nike.png" }, ] // Função para gerar um sinal aleatório const generateRandomSignal = (id: number): Signal => { const assetIndex = Math.floor(Math.random() * assets.length) const asset = assets[assetIndex].name const assetLogo = assets[assetIndex].logo const type: SignalType = Math.random() > 0.5 ? "COMPRA" : "VENDA" // Escolher aleatoriamente entre M1, M5 e M15 const expirations: ExpirationTime[] = ["M1", "M5", "M15"] const expiration = expirations[Math.floor(Math.random() * expirations.length)] // Calcular tempo de expiração em milissegundos const expirationMinutes = expiration === "M1" ? 1 : expiration === "M5" ? 5 : 15 const expirationMs = expirationMinutes * 60 * 1000 // Usar o horário atual (que será o mesmo da corretora Avalon) const now = new Date() const hours = now.getHours().toString().padStart(2, "0") const minutes = now.getMinutes().toString().padStart(2, "0") const seconds = now.getSeconds().toString().padStart(2, "0") const time = `${hours}:${minutes}:${seconds}` const day = now.getDate().toString().padStart(2, "0") const month = (now.getMonth() + 1).toString().padStart(2, "0") const year = now.getFullYear() const date = `${day}/${month}/${year}` const timestamp = now.getTime() const expirationTimestamp = timestamp + expirationMs return { id, asset, assetLogo, type, expiration, date, time, timestamp, expirationTimestamp, } } // Gerar sinais iniciais (200 sinais) const generateInitialSignals = (): Signal[] => { const signals: Signal[] = [] // Gerar 200 sinais for (let i = 0; i < 200; i++) { signals.push(generateRandomSignal(i + 1)) } return signals.sort((a, b) => b.timestamp - a.timestamp) } export default function DashboardPage() { const [signals, setSignals] = useState([]) const [nextId, setNextId] = useState(1) const [currentTime, setCurrentTime] = useState(new Date()) useEffect(() => { // Carregar sinais iniciais const initialSignals = generateInitialSignals() setSignals(initialSignals) setNextId(initialSignals.length + 1) // Atualizar sinais a cada 2min30s const signalInterval = setInterval( () => { const newSignal = generateRandomSignal(nextId) setSignals((prev) => [newSignal, ...prev]) setNextId((prev) => prev + 1) }, 2.5 * 60 * 1000, ) // 2min30s em milissegundos // Atualizar o horário atual a cada segundo const timeInterval = setInterval(() => { setCurrentTime(new Date()) }, 1000) return () => { clearInterval(signalInterval) clearInterval(timeInterval) } }, [nextId]) // Formatar o horário atual no formato HH:MM:SS const formattedTime = currentTime.toLocaleTimeString("pt-BR", { hour: "2-digit", minute: "2-digit", second: "2-digit", hour12: false, }) return (

Sinais em Tempo Real

Atualizados a cada 2 minutos e 30 segundos

Horário Avalon: {formattedTime}

{/* Bot Trader Avalon Image */}

Ativo

Direção

Expiração

Horário

Tempo Restante para Operação

{signals.map((signal) => (

{signal.asset}

{signal.type === "COMPRA" ? ( COMPRA ) : ( VENDA )}

{signal.expiration}

{signal.time}

))}

Comece a operar agora mesmo

Cadastre-se na corretora Avalon e comece a lucrar com nossos sinais

) } [V0_FILE]typescriptreact:file="app/cadastro/page.tsx" isEdit="true" isQuickEdit="true" isMerged="true" "use client" import type React from "react" import { useState } from "react" import Link from "next/link" import { useRouter } from "next/navigation" import { Eye, EyeOff } from "lucide-react" 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" export default function CadastroPage() { const router = useRouter() const { toast } = useToast() const [showPassword, setShowPassword] = useState(false) const [isLoading, setIsLoading] = useState(false) const [formData, setFormData] = useState({ name: "", email: "", password: "", }) const handleChange = (e: React.ChangeEvent) => { const { name, value } = e.target setFormData((prev) => ({ ...prev, [name]: value })) } const handleSubmit = (e: React.FormEvent) => { e.preventDefault() setIsLoading(true) // Simulação de cadastro - em uma aplicação real, você enviaria para uma API setTimeout(() => { // Verificar se o email já está cadastrado const storedUser = localStorage.getItem("user") if (storedUser && JSON.parse(storedUser).email === formData.email) { toast({ title: "Email já cadastrado", description: "Este email já está em uso. Tente fazer login.", variant: "destructive", }) setIsLoading(false) return } localStorage.setItem("user", JSON.stringify({ ...formData, isLoggedIn: true })) router.push("/dashboard") toast({ title: "Cadastro realizado com sucesso!", description: "Você foi redirecionado para o dashboard.", variant: "default", }) setIsLoading(false) }, 1500) } return (

Criar Conta

Cadastre-se para acessar o Bot de Sinais Avalon

Já tem uma conta?{" "} Faça login

) } [V0_FILE]typescriptreact:file="app/login/page.tsx" isEdit="true" isQuickEdit="true" isMerged="true" "use client" import type React from "react" import { useState } from "react" import Link from "next/link" import { useRouter } from "next/navigation" import { Eye, EyeOff } from "lucide-react" 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" export default function LoginPage() { const router = useRouter() const { toast } = useToast() const [showPassword, setShowPassword] = useState(false) const [formData, setFormData] = useState({ email: "", password: "", }) const [isLoading, setIsLoading] = useState(false) const handleChange = (e: React.ChangeEvent) => { const { name, value } = e.target setFormData((prev) => ({ ...prev, [name]: value })) } const handleSubmit = (e: React.FormEvent) => { e.preventDefault() setIsLoading(true) // Simulação de login - em uma aplicação real, você verificaria com uma API setTimeout(() => { const storedUser = localStorage.getItem("user") if (storedUser) { const userData = JSON.parse(storedUser) if (userData.email === formData.email && userData.password === formData.password) { localStorage.setItem("user", JSON.stringify({ ...userData, isLoggedIn: true })) router.push("/dashboard") toast({ title: "Login realizado com sucesso!", description: "Você foi redirecionado para o dashboard.", variant: "default", }) } else { toast({ title: "Erro de autenticação", description: "Email ou senha incorretos. Tente novamente.", variant: "destructive", }) } } else { toast({ title: "Usuário não encontrado", description: "Este email não está cadastrado. Crie uma conta primeiro.", variant: "destructive", }) } setIsLoading(false) }, 1500) } return (

Entrar

Acesse o Bot de Sinais Avalon

Não tem uma conta?{" "} Cadastre-se

) } [V0_FILE]typescriptreact:file="components/login-modal.tsx" isEdit="true" "use client" import type React from "react" import { cn } from "@/lib/utils" import { useState } from "react" import { useRouter } from "next/navigation" import { Eye, EyeOff, LogIn } from "lucide-react" import { Button } from "@/components/ui/button" import { Input } from "@/components/ui/input" import { Label } from "@/components/ui/label" import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle, DialogTrigger, } from "@/components/ui/dialog" import { useToast } from "@/components/ui/use-toast" export function LoginModal({ triggerClassName, triggerSize, }: { triggerClassName?: string; triggerSize?: "default" | "sm" | "lg" | "icon" }) { const router = useRouter() const { toast } = useToast() const [showPassword, setShowPassword] = useState(false) const [formData, setFormData] = useState({ email: "", password: "", }) const [isLoading, setIsLoading] = useState(false) const [open, setOpen] = useState(false) const handleChange = (e: React.ChangeEvent) => { const { name, value } = e.target setFormData((prev) => ({ ...prev, [name]: value })) } const handleSubmit = (e: React.FormEvent) => { e.preventDefault() setIsLoading(true) // Simulação de login - em uma aplicação real, você verificaria com uma API setTimeout(() => { const storedUser = localStorage.getItem("user") if (storedUser) { const userData = JSON.parse(storedUser) if (userData.email === formData.email && userData.password === formData.password) { localStorage.setItem("user", JSON.stringify({ ...userData, isLoggedIn: true })) setOpen(false) router.push("/dashboard") } else { toast({ title: "Erro de autenticação", description: "Email ou senha incorretos. Tente novamente.", variant: "destructive", }) } } else { toast({ title: "Usuário não encontrado", description: "Este email não está cadastrado. Crie uma conta primeiro.", variant: "destructive", }) } setIsLoading(false) }, 1500) } return ( ) } [V0_FILE]typescriptreact:file="components/register-modal.tsx" isEdit="true" "use client" import type React from "react" import { cn } from "@/lib/utils" import { useState } from "react" import { useRouter } from "next/navigation" import { Eye, EyeOff, UserPlus } from "lucide-react" import { Button } from "@/components/ui/button" import { Input } from "@/components/ui/input" import { Label } from "@/components/ui/label" import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle, DialogTrigger, } from "@/components/ui/dialog" import { useToast } from "@/components/ui/use-toast" export function RegisterModal({ triggerClassName, triggerSize, }: { triggerClassName?: string; triggerSize?: "default" | "sm" | "lg" | "icon" }) { const router = useRouter() const { toast } = useToast() const [showPassword, setShowPassword] = useState(false) const [formData, setFormData] = useState({ name: "", email: "", password: "", }) const [isLoading, setIsLoading] = useState(false) const [open, setOpen] = useState(false) const handleChange = (e: React.ChangeEvent) => { const { name, value } = e.target setFormData((prev) => ({ ...prev, [name]: value })) } const handleSubmit = (e: React.FormEvent) => { e.preventDefault() setIsLoading(true) // Simulação de cadastro - em uma aplicação real, você enviaria para uma API setTimeout(() => { // Verificar se o email já está cadastrado const storedUser = localStorage.getItem("user") if (storedUser && JSON.parse(storedUser).email === formData.email) { toast({ title: "Email já cadastrado", description: "Este email já está em uso. Tente fazer login.", variant: "destructive", }) setIsLoading(false) return } localStorage.setItem("user", JSON.stringify({ ...formData, isLoggedIn: true })) setOpen(false) router.push("/dashboard") setIsLoading(false) }, 1500) } return ( ) } [V0_FILE]typescriptreact:file="app/page.tsx" isEdit="true" "use client" import Image from "next/image" import { CheckCircle } from "lucide-react" import { CompanyLogos } from "@/components/company-logos" import { LoginModal } from "@/components/login-modal" import { RegisterModal } from "@/components/register-modal" export default function LandingPage() { return (

{/* Header */}

AVALON

{/* Botões de Login e Cadastro no Header */}

{/* Hero Section */}

Inteligência Artificial Avançada

Bot de Sinais{" "} Avalon

Receba sinais de compra e venda com{" "} 85% de assertividade

{/* Botões de Login e Cadastro na Hero Section */}

{/* Bot Trader Avalon Image */}

{/* Ativos Globais Section */}

Ativos Globais com Alto Potencial

Na Avalon, oferecemos exposição aos maiores mercados do mundo, com empresas que movimentam bilhões de dólares diariamente. Nossos usuários podem investir com facilidade em ativos de gigantes globais, incluindo:

Google (Alphabet) – Líder global em tecnologia e publicidade digital.
Apple – A empresa mais valiosa do mundo, referência em inovação.
Nike – Potência global no setor de vestuário esportivo.
Coca-Cola – Marca mais reconhecida do setor de bebidas no planeta.
Amazon – Dominante no comércio eletrônico e serviços em nuvem.
Tesla – Inovadora no setor de veículos elétricos e energia limpa.
McDonald's – Rede de fast-food mais famosa do mundo.
Meta (Facebook, Instagram, WhatsApp) – Referência global em redes sociais e metaverso.

Esses ativos representam estabilidade, crescimento e uma forte presença internacional, proporcionando oportunidades reais e sustentáveis para investidores.

{/* Bot Inteligente Section */}

Bot Inteligente de Sinais de Mercado

Nossa plataforma conta com um bot exclusivo, alimentado por inteligência artificial, que monitora os mercados em tempo real.

Geração de sinais a cada 2 minutos e 30 segundos

Atualizações frequentes para aproveitar as melhores oportunidades
Taxa de acerto de até 85%

Precisão comprovada para maximizar seus resultados
Baseado em grandes volumes de dados

Análise de padrões de mercado e tecnologia preditiva avançada
Ideal para traders de todos os níveis

Sinais claros, rápidos e eficientes para maximizar seus lucros

Este bot é uma ferramenta poderosa desenvolvida para maximizar os lucros dos nossos usuários, fornecendo sinais claros, rápidos e eficientes.

{/* Trader Success Section */}

Traders de Sucesso Escolhem Avalon

Análise Técnica Avançada

Nossos traders utilizam as mais modernas ferramentas de análise para identificar oportunidades.

Mercados em Alta

Aproveite as melhores oportunidades em mercados com tendência de alta.

Lucros Consistentes

Estratégias comprovadas para gerar resultados positivos consistentes.

{/* Company Logos */} {/* Features Section */}

Benefícios do Bot Avalon

Ativos Premium

Sinais para ativos de alta liquidez: Amazon, Nike, McDonald's, Coca-Cola, Tesla, Meta, Google, Apple.

Múltiplas Expirações

Escolha entre expirações de 1 minuto (M1), 5 minutos (M5) ou 15 minutos (M15) para cada sinal.

Atualizações Frequentes

Sinais atualizados a cada 2 minutos e 30 segundos para máxima precisão.

Alta Assertividade

85% de assertividade comprovada nos sinais enviados.

Contagem Regressiva

Acompanhe o tempo restante de cada sinal com nossa contagem regressiva em tempo real.

Calculadoras Avançadas

Ferramentas exclusivas para calcular lucros e juros compostos para maximizar seus ganhos.

{/* CTA Section */}

Comece a lucrar agora mesmo

Junte-se a milhares de traders que já estão lucrando com o Bot de Sinais Avalon

{/* Botões de Login e Cadastro na CTA Section */}

) }

404

Página não encontrada

Calculadora de Meta Diária

Projeção de 30 dias:

{title}

Ativos Disponíveis

Calculadora de Gerenciamento de Entradas

Resumo do Gerenciamento

Resultado Esperado

Recomendações

Calculadora de Juros Compostos

Resumo

Ferramentas de Cálculo

Sinais em Tempo Real

Comece a operar agora mesmo

Criar Conta

Entrar

Bot de Sinais{" "} Avalon

Ativos Globais com Alto Potencial

Bot Inteligente de Sinais de Mercado

Geração de sinais a cada 2 minutos e 30 segundos

Taxa de acerto de até 85%

Baseado em grandes volumes de dados

Ideal para traders de todos os níveis

Traders de Sucesso Escolhem Avalon

Análise Técnica Avançada

Mercados em Alta

Lucros Consistentes

Benefícios do Bot Avalon

Ativos Premium

Múltiplas Expirações

Atualizações Frequentes

Alta Assertividade

Contagem Regressiva

Calculadoras Avançadas

Comece a lucrar agora mesmo