Merge branch 'main' into veganbeef/deploy-script-update

src/app/api/auth/nonce/route.ts

@@ -0,0 +1,16 @@
+import { NextResponse } from 'next/server';
+import { getNeynarClient } from '~/lib/neynar';
+
+export async function GET() {
+  try {
+    const client = getNeynarClient();
+    const response = await client.fetchNonce();
+    return NextResponse.json(response);
+  } catch (error) {
+    console.error('Error fetching nonce:', error);
+    return NextResponse.json(
+      { error: 'Failed to fetch nonce' },
+      { status: 500 }
+    );
+  }
+}

src/app/api/auth/session-signers/route.ts

@@ -0,0 +1,43 @@
+import { NextResponse } from 'next/server';
+import { getNeynarClient } from '~/lib/neynar';
+
+export async function GET(request: Request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const message = searchParams.get('message');
+    const signature = searchParams.get('signature');
+
+    if (!message || !signature) {
+      return NextResponse.json(
+        { error: 'Message and signature are required' },
+        { status: 400 }
+      );
+    }
+
+    const client = getNeynarClient();
+    const data = await client.fetchSigners({ message, signature });
+    const signers = data.signers;
+
+    // Fetch user data if signers exist
+    let user = null;
+    if (signers && signers.length > 0 && signers[0].fid) {
+      const {
+        users: [fetchedUser],
+      } = await client.fetchBulkUsers({
+        fids: [signers[0].fid],
+      });
+      user = fetchedUser;
+    }
+
+    return NextResponse.json({
+      signers,
+      user,
+    });
+  } catch (error) {
+    console.error('Error in session-signers API:', error);
+    return NextResponse.json(
+      { error: 'Failed to fetch signers' },
+      { status: 500 }
+    );
+  }
+}

src/app/api/auth/signer/route.ts

@@ -0,0 +1,42 @@
+import { NextResponse } from 'next/server';
+import { getNeynarClient } from '~/lib/neynar';
+
+export async function POST() {
+  try {
+    const neynarClient = getNeynarClient();
+    const signer = await neynarClient.createSigner();
+    return NextResponse.json(signer);
+  } catch (error) {
+    console.error('Error fetching signer:', error);
+    return NextResponse.json(
+      { error: 'Failed to fetch signer' },
+      { status: 500 }
+    );
+  }
+}
+
+export async function GET(request: Request) {
+  const { searchParams } = new URL(request.url);
+  const signerUuid = searchParams.get('signerUuid');
+
+  if (!signerUuid) {
+    return NextResponse.json(
+      { error: 'signerUuid is required' },
+      { status: 400 }
+    );
+  }
+
+  try {
+    const neynarClient = getNeynarClient();
+    const signer = await neynarClient.lookupSigner({
+      signerUuid,
+    });
+    return NextResponse.json(signer);
+  } catch (error) {
+    console.error('Error fetching signed key:', error);
+    return NextResponse.json(
+      { error: 'Failed to fetch signed key' },
+      { status: 500 }
+    );
+  }
+}

src/app/api/auth/signer/signed_key/route.ts

@@ -0,0 +1,91 @@
+import { NextResponse } from 'next/server';
+import { getNeynarClient } from '~/lib/neynar';
+import { mnemonicToAccount } from 'viem/accounts';
+import {
+  SIGNED_KEY_REQUEST_TYPE,
+  SIGNED_KEY_REQUEST_VALIDATOR_EIP_712_DOMAIN,
+} from '~/lib/constants';
+
+const postRequiredFields = ['signerUuid', 'publicKey'];
+
+export async function POST(request: Request) {
+  const body = await request.json();
+
+  // Validate required fields
+  for (const field of postRequiredFields) {
+    if (!body[field]) {
+      return NextResponse.json(
+        { error: `${field} is required` },
+        { status: 400 }
+      );
+    }
+  }
+
+  const { signerUuid, publicKey, redirectUrl } = body;
+
+  if (redirectUrl && typeof redirectUrl !== 'string') {
+    return NextResponse.json(
+      { error: 'redirectUrl must be a string' },
+      { status: 400 }
+    );
+  }
+
+  try {
+    // Get the app's account from seed phrase
+    const seedPhrase = process.env.SEED_PHRASE;
+    const shouldSponsor = process.env.SPONSOR_SIGNER === 'true';
+
+    if (!seedPhrase) {
+      return NextResponse.json(
+        { error: 'App configuration missing (SEED_PHRASE or FID)' },
+        { status: 500 }
+      );
+    }
+
+    const neynarClient = getNeynarClient();
+
+    const account = mnemonicToAccount(seedPhrase);
+
+    const {
+      user: { fid },
+    } = await neynarClient.lookupUserByCustodyAddress({
+      custodyAddress: account.address,
+    });
+
+    const appFid = fid;
+
+    // Generate deadline (24 hours from now)
+    const deadline = Math.floor(Date.now() / 1000) + 86400;
+
+    // Generate EIP-712 signature
+    const signature = await account.signTypedData({
+      domain: SIGNED_KEY_REQUEST_VALIDATOR_EIP_712_DOMAIN,
+      types: {
+        SignedKeyRequest: SIGNED_KEY_REQUEST_TYPE,
+      },
+      primaryType: 'SignedKeyRequest',
+      message: {
+        requestFid: BigInt(appFid),
+        key: publicKey,
+        deadline: BigInt(deadline),
+      },
+    });
+
+    const signer = await neynarClient.registerSignedKey({
+      appFid,
+      deadline,
+      signature,
+      signerUuid,
+      ...(redirectUrl && { redirectUrl }),
+      ...(shouldSponsor && { sponsor: { sponsored_by_neynar: true } }),
+    });
+
+    return NextResponse.json(signer);
+  } catch (error) {
+    console.error('Error registering signed key:', error);
+    return NextResponse.json(
+      { error: 'Failed to register signed key' },
+      { status: 500 }
+    );
+  }
+}

src/app/api/auth/signers/route.ts

@@ -0,0 +1,38 @@
+import { NextResponse } from 'next/server';
+import { getNeynarClient } from '~/lib/neynar';
+
+const requiredParams = ['message', 'signature'];
+
+export async function GET(request: Request) {
+  const { searchParams } = new URL(request.url);
+  const params: Record<string, string | null> = {};
+  for (const param of requiredParams) {
+    params[param] = searchParams.get(param);
+    if (!params[param]) {
+      return NextResponse.json(
+        {
+          error: `${param} parameter is required`,
+        },
+        { status: 400 }
+      );
+    }
+  }
+
+  const message = params.message as string;
+  const signature = params.signature as string;
+
+  try {
+    const client = getNeynarClient();
+    const data = await client.fetchSigners({ message, signature });
+    const signers = data.signers;
+    return NextResponse.json({
+      signers,
+    });
+  } catch (error) {
+    console.error('Error fetching signers:', error);
+    return NextResponse.json(
+      { error: 'Failed to fetch signers' },
+      { status: 500 }
+    );
+  }
+}

src/app/api/auth/update-session/route.ts

@@ -0,0 +1,46 @@
+import { NextResponse } from 'next/server';
+import { getServerSession } from 'next-auth';
+import { authOptions } from '~/auth';
+
+export async function POST(request: Request) {
+  try {
+    const session = await getServerSession(authOptions);
+
+    if (!session?.user?.fid) {
+      return NextResponse.json(
+        { error: 'No authenticated session found' },
+        { status: 401 }
+      );
+    }
+
+    const body = await request.json();
+    const { signers, user } = body;
+
+    if (!signers || !user) {
+      return NextResponse.json(
+        { error: 'Signers and user are required' },
+        { status: 400 }
+      );
+    }
+
+    // For NextAuth to update the session, we need to trigger the JWT callback
+    // This is typically done by calling the session endpoint with updated data
+    // However, we can't directly modify the session token from here
+
+    // Instead, we'll store the data temporarily and let the client refresh the session
+    // The session will be updated when the JWT callback is triggered
+
+    return NextResponse.json({
+      success: true,
+      message: 'Session update prepared',
+      signers,
+      user,
+    });
+  } catch (error) {
+    console.error('Error preparing session update:', error);
+    return NextResponse.json(
+      { error: 'Failed to prepare session update' },
+      { status: 500 }
+    );
+  }
+}

src/app/providers.tsx

@@ -1,27 +1,38 @@
-"use client";
+'use client';
 
-import dynamic from "next/dynamic";
-import type { Session } from "next-auth";
-import { SessionProvider } from "next-auth/react";
-import { MiniAppProvider } from "@neynar/react";
-import { SafeFarcasterSolanaProvider } from "~/components/providers/SafeFarcasterSolanaProvider";
-import { ANALYTICS_ENABLED } from "~/lib/constants";
+import dynamic from 'next/dynamic';
+import type { Session } from 'next-auth';
+import { SessionProvider } from 'next-auth/react';
+import { MiniAppProvider } from '@neynar/react';
+import { SafeFarcasterSolanaProvider } from '~/components/providers/SafeFarcasterSolanaProvider';
+import { ANALYTICS_ENABLED } from '~/lib/constants';
+import { AuthKitProvider } from '@farcaster/auth-kit';
 
 const WagmiProvider = dynamic(
-  () => import("~/components/providers/WagmiProvider"),
+  () => import('~/components/providers/WagmiProvider'),
   {
     ssr: false,
   }
 );
 
-export function Providers({ session, children }: { session: Session | null, children: React.ReactNode }) {
-  const solanaEndpoint = process.env.SOLANA_RPC_ENDPOINT || "https://solana-rpc.publicnode.com";
+export function Providers({
+  session,
+  children,
+}: {
+  session: Session | null;
+  children: React.ReactNode;
+}) {
+  const solanaEndpoint =
+    process.env.SOLANA_RPC_ENDPOINT || 'https://solana-rpc.publicnode.com';
   return (
     <SessionProvider session={session}>
       <WagmiProvider>
-        <MiniAppProvider analyticsEnabled={ANALYTICS_ENABLED} backButtonEnabled={true}>
+        <MiniAppProvider
+          analyticsEnabled={ANALYTICS_ENABLED}
+          backButtonEnabled={true}
+        >
           <SafeFarcasterSolanaProvider endpoint={solanaEndpoint}>
-            {children}
+            <AuthKitProvider config={{}}>{children}</AuthKitProvider>
           </SafeFarcasterSolanaProvider>
         </MiniAppProvider>
       </WagmiProvider>

src/auth.ts

@@ -1,11 +1,200 @@
-import { AuthOptions, getServerSession } from "next-auth"
-import CredentialsProvider from "next-auth/providers/credentials";
-import { createAppClient, viemConnector } from "@farcaster/auth-client";
+import { AuthOptions, getServerSession } from 'next-auth';
+import CredentialsProvider from 'next-auth/providers/credentials';
+import { createAppClient, viemConnector } from '@farcaster/auth-client';
 
-declare module "next-auth" {
+declare module 'next-auth' {
   interface Session {
-    user: {
+    provider?: string;
+    user?: {
       fid: number;
+      object?: 'user';
+      username?: string;
+      display_name?: string;
+      pfp_url?: string;
+      custody_address?: string;
+      profile?: {
+        bio: {
+          text: string;
+          mentioned_profiles?: Array<{
+            object: 'user_dehydrated';
+            fid: number;
+            username: string;
+            display_name: string;
+            pfp_url: string;
+            custody_address: string;
+          }>;
+          mentioned_profiles_ranges?: Array<{
+            start: number;
+            end: number;
+          }>;
+        };
+        location?: {
+          latitude: number;
+          longitude: number;
+          address: {
+            city: string;
+            state: string;
+            country: string;
+            country_code: string;
+          };
+        };
+      };
+      follower_count?: number;
+      following_count?: number;
+      verifications?: string[];
+      verified_addresses?: {
+        eth_addresses: string[];
+        sol_addresses: string[];
+        primary: {
+          eth_address: string;
+          sol_address: string;
+        };
+      };
+      verified_accounts?: Array<Record<string, unknown>>;
+      power_badge?: boolean;
+      url?: string;
+      experimental?: {
+        neynar_user_score: number;
+        deprecation_notice: string;
+      };
+      score?: number;
+    };
+    signers?: {
+      object: 'signer';
+      signer_uuid: string;
+      public_key: string;
+      status: 'approved';
+      fid: number;
+    }[];
+  }
+
+  interface User {
+    provider?: string;
+    signers?: Array<{
+      object: 'signer';
+      signer_uuid: string;
+      public_key: string;
+      status: 'approved';
+      fid: number;
+    }>;
+    user?: {
+      object: 'user';
+      fid: number;
+      username: string;
+      display_name: string;
+      pfp_url: string;
+      custody_address: string;
+      profile: {
+        bio: {
+          text: string;
+          mentioned_profiles?: Array<{
+            object: 'user_dehydrated';
+            fid: number;
+            username: string;
+            display_name: string;
+            pfp_url: string;
+            custody_address: string;
+          }>;
+          mentioned_profiles_ranges?: Array<{
+            start: number;
+            end: number;
+          }>;
+        };
+        location?: {
+          latitude: number;
+          longitude: number;
+          address: {
+            city: string;
+            state: string;
+            country: string;
+            country_code: string;
+          };
+        };
+      };
+      follower_count: number;
+      following_count: number;
+      verifications: string[];
+      verified_addresses: {
+        eth_addresses: string[];
+        sol_addresses: string[];
+        primary: {
+          eth_address: string;
+          sol_address: string;
+        };
+      };
+      verified_accounts: Array<Record<string, unknown>>;
+      power_badge: boolean;
+      url?: string;
+      experimental?: {
+        neynar_user_score: number;
+        deprecation_notice: string;
+      };
+      score: number;
+    };
+  }
+
+  interface JWT {
+    provider?: string;
+    signers?: Array<{
+      object: 'signer';
+      signer_uuid: string;
+      public_key: string;
+      status: 'approved';
+      fid: number;
+    }>;
+    user?: {
+      object: 'user';
+      fid: number;
+      username: string;
+      display_name: string;
+      pfp_url: string;
+      custody_address: string;
+      profile: {
+        bio: {
+          text: string;
+          mentioned_profiles?: Array<{
+            object: 'user_dehydrated';
+            fid: number;
+            username: string;
+            display_name: string;
+            pfp_url: string;
+            custody_address: string;
+          }>;
+          mentioned_profiles_ranges?: Array<{
+            start: number;
+            end: number;
+          }>;
+        };
+        location?: {
+          latitude: number;
+          longitude: number;
+          address: {
+            city: string;
+            state: string;
+            country: string;
+            country_code: string;
+          };
+        };
+      };
+      follower_count: number;
+      following_count: number;
+      verifications: string[];
+      verified_addresses: {
+        eth_addresses: string[];
+        sol_addresses: string[];
+        primary: {
+          eth_address: string;
+          sol_address: string;
+        };
+      };
+      verified_accounts?: Array<Record<string, unknown>>;
+      power_badge?: boolean;
+      url?: string;
+      experimental?: {
+        neynar_user_score: number;
+        deprecation_notice: string;
+      };
+      score?: number;
     };
   }
 }
@@ -26,43 +215,49 @@ function getDomainFromUrl(urlString: string | undefined): string {
 }
 
 export const authOptions: AuthOptions = {
-    // Configure one or more authentication providers
+  // Configure one or more authentication providers
   providers: [
     CredentialsProvider({
-      name: "Sign in with Farcaster",
+      id: 'farcaster',
+      name: 'Sign in with Farcaster',
       credentials: {
         message: {
-          label: "Message",
-          type: "text",
-          placeholder: "0x0",
+          label: 'Message',
+          type: 'text',
+          placeholder: '0x0',
         },
         signature: {
-          label: "Signature",
-          type: "text",
-          placeholder: "0x0",
+          label: 'Signature',
+          type: 'text',
+          placeholder: '0x0',
+        },
+        nonce: {
+          label: 'Nonce',
+          type: 'text',
+          placeholder: 'Custom nonce (optional)',
         },
         // In a production app with a server, these should be fetched from
         // your Farcaster data indexer rather than have them accepted as part
         // of credentials.
         // question: should these natively use the Neynar API?
         name: {
-          label: "Name",
-          type: "text",
-          placeholder: "0x0",
+          label: 'Name',
+          type: 'text',
+          placeholder: '0x0',
         },
         pfp: {
-          label: "Pfp",
-          type: "text",
-          placeholder: "0x0",
+          label: 'Pfp',
+          type: 'text',
+          placeholder: '0x0',
         },
       },
       async authorize(credentials, req) {
-        const csrfToken = req?.body?.csrfToken;
-        if (!csrfToken) {
-          console.error('CSRF token is missing from request');
+        const nonce = req?.body?.csrfToken;
+
+        if (!nonce) {
+          console.error('No nonce or CSRF token provided');
           return null;
         }
-
         const appClient = createAppClient({
           ethereum: viemConnector(),
         });
@@ -73,8 +268,9 @@ export const authOptions: AuthOptions = {
           message: credentials?.message as string,
           signature: credentials?.signature as `0x${string}`,
           domain,
-          nonce: csrfToken,
+          nonce,
         });
+
         const { success, fid } = verifyResponse;
 
         if (!success) {
@@ -83,47 +279,155 @@ export const authOptions: AuthOptions = {
 
         return {
           id: fid.toString(),
+          name: credentials?.name || `User ${fid}`,
+          image: credentials?.pfp || null,
+          provider: 'farcaster',
         };
       },
     }),
+    CredentialsProvider({
+      id: 'neynar',
+      name: 'Sign in with Neynar',
+      credentials: {
+        message: {
+          label: 'Message',
+          type: 'text',
+          placeholder: '0x0',
+        },
+        signature: {
+          label: 'Signature',
+          type: 'text',
+          placeholder: '0x0',
+        },
+        nonce: {
+          label: 'Nonce',
+          type: 'text',
+          placeholder: 'Custom nonce (optional)',
+        },
+        fid: {
+          label: 'FID',
+          type: 'text',
+          placeholder: '0',
+        },
+        signers: {
+          label: 'Signers',
+          type: 'text',
+          placeholder: 'JSON string of signers',
+        },
+        user: {
+          label: 'User Data',
+          type: 'text',
+          placeholder: 'JSON string of user data',
+        },
+      },
+      async authorize(credentials) {
+        const nonce = credentials?.nonce;
+
+        if (!nonce) {
+          console.error('No nonce or CSRF token provided for Neynar auth');
+          return null;
+        }
+
+        // For Neynar, we can use a different validation approach
+        // This could involve validating against Neynar's API or using their SDK
+        try {
+          // Validate the signature using Farcaster's auth client (same as Farcaster provider)
+          const appClient = createAppClient({
+            ethereum: viemConnector(),
+          });
+
+          const domain = getDomainFromUrl(process.env.NEXTAUTH_URL);
+
+          const verifyResponse = await appClient.verifySignInMessage({
+            message: credentials?.message as string,
+            signature: credentials?.signature as `0x${string}`,
+            domain,
+            nonce,
+          });
+
+          const { success, fid } = verifyResponse;
+
+          if (!success) {
+            return null;
+          }
+
+          // Validate that the provided FID matches the verified FID
+          if (credentials?.fid && parseInt(credentials.fid) !== fid) {
+            console.error('FID mismatch in Neynar auth');
+            return null;
+          }
+
+          return {
+            id: fid.toString(),
+            provider: 'neynar',
+            signers: credentials?.signers
+              ? JSON.parse(credentials.signers)
+              : undefined,
+            user: credentials?.user ? JSON.parse(credentials.user) : undefined,
+          };
+        } catch (error) {
+          console.error('Error in Neynar auth:', error);
+          return null;
+        }
+      },
+    }),
   ],
   callbacks: {
     session: async ({ session, token }) => {
-      if (session?.user) {
-        session.user.fid = parseInt(token.sub ?? '');
+      // Set provider at the root level
+      session.provider = token.provider as string;
+
+      if (token.provider === 'farcaster') {
+        // For Farcaster, simple structure
+        session.user = {
+          fid: parseInt(token.sub ?? ''),
+        };
+      } else if (token.provider === 'neynar') {
+        // For Neynar, use full user data structure from user
+        session.user = token.user as typeof session.user;
+        session.signers = token.signers as typeof session.signers;
       }
+
       return session;
     },
+    jwt: async ({ token, user }) => {
+      if (user) {
+        token.provider = user.provider;
+        token.signers = user.signers;
+        token.user = user.user;
+      }
+      return token;
+    },
   },
   cookies: {
     sessionToken: {
       name: `next-auth.session-token`,
       options: {
         httpOnly: true,
-        sameSite: "none",
-        path: "/",
-        secure: true
-      }
+        sameSite: 'none',
+        path: '/',
+        secure: true,
+      },
     },
     callbackUrl: {
       name: `next-auth.callback-url`,
       options: {
-        sameSite: "none",
-        path: "/",
-        secure: true
-      }
+        sameSite: 'none',
+        path: '/',
+        secure: true,
+      },
     },
     csrfToken: {
       name: `next-auth.csrf-token`,
       options: {
         httpOnly: true,
-        sameSite: "none",
-        path: "/",
-        secure: true
-      }
-    }
-  }
-}
+        sameSite: 'none',
+        path: '/',
+        secure: true,
+      },
+    },
+  },
+};
 
 export const getSession = async () => {
   try {
@@ -132,4 +436,4 @@ export const getSession = async () => {
     console.error('Error getting server session:', error);
     return null;
   }
-}
+};

src/components/ui/NeynarAuthButton/AuthDialog.tsx

@@ -0,0 +1,221 @@
+'use client';
+
+export function AuthDialog({
+  open,
+  onClose,
+  url,
+  isError,
+  error,
+  step,
+  isLoading,
+  signerApprovalUrl,
+}: {
+  open: boolean;
+  onClose: () => void;
+  url?: string;
+  isError: boolean;
+  error?: Error | null;
+  step: 'signin' | 'access' | 'loading';
+  isLoading?: boolean;
+  signerApprovalUrl?: string | null;
+}) {
+  if (!open) return null;
+
+  const getStepContent = () => {
+    switch (step) {
+      case 'signin':
+        return {
+          title: 'Sign in',
+          description:
+            "To sign in, scan the code below with your phone's camera.",
+          showQR: true,
+          qrUrl: url,
+          showOpenButton: true,
+        };
+
+      case 'loading':
+        return {
+          title: 'Setting up access...',
+          description:
+            'Checking your account permissions and setting up secure access.',
+          showQR: false,
+          qrUrl: '',
+          showOpenButton: false,
+        };
+
+      case 'access':
+        return {
+          title: 'Grant Access',
+          description: (
+            <div className="space-y-3">
+              <p className="text-gray-600 dark:text-gray-400">
+                Allow this app to access your Farcaster account:
+              </p>
+              <div className="space-y-2 text-sm">
+                <div className="flex items-center gap-3 p-3 bg-gray-50 dark:bg-gray-700 rounded-lg">
+                  <div className="w-6 h-6 bg-green-100 dark:bg-green-900 rounded-full flex items-center justify-center">
+                    <svg
+                      className="w-3 h-3 text-green-600 dark:text-green-400"
+                      fill="currentColor"
+                      viewBox="0 0 20 20"
+                    >
+                      <path
+                        fillRule="evenodd"
+                        d="M16.707 5.293a1 1 0 010 1.414l-8 8a1 1 0 01-1.414 0l-4-4a1 1 0 011.414-1.414L8 12.586l7.293-7.293a1 1 0 011.414 0z"
+                        clipRule="evenodd"
+                      />
+                    </svg>
+                  </div>
+                  <div>
+                    <div className="font-medium text-gray-900 dark:text-gray-100">
+                      Read Access
+                    </div>
+                    <div className="text-gray-500 dark:text-gray-400">
+                      View your profile and public information
+                    </div>
+                  </div>
+                </div>
+                <div className="flex items-center gap-3 p-3 bg-gray-50 dark:bg-gray-700 rounded-lg">
+                  <div className="w-6 h-6 bg-blue-100 dark:bg-blue-900 rounded-full flex items-center justify-center">
+                    <svg
+                      className="w-3 h-3 text-blue-600 dark:text-blue-400"
+                      fill="currentColor"
+                      viewBox="0 0 20 20"
+                    >
+                      <path d="M13.586 3.586a2 2 0 112.828 2.828l-.793.793-2.828-2.828.793-.793zM11.379 5.793L3 14.172V17h2.828l8.38-8.379-2.83-2.828z" />
+                    </svg>
+                  </div>
+                  <div>
+                    <div className="font-medium text-gray-900 dark:text-gray-100">
+                      Write Access
+                    </div>
+                    <div className="text-gray-500 dark:text-gray-400">
+                      Post casts, likes, and update your profile
+                    </div>
+                  </div>
+                </div>
+              </div>
+            </div>
+          ),
+          // Show QR code if we have signer approval URL, otherwise show loading
+          showQR: !!signerApprovalUrl,
+          qrUrl: signerApprovalUrl || '',
+          showOpenButton: !!signerApprovalUrl,
+        };
+
+      default:
+        return {
+          title: 'Sign in',
+          description:
+            "To signin, scan the code below with your phone's camera.",
+          showQR: true,
+          qrUrl: url,
+          showOpenButton: true,
+        };
+    }
+  };
+
+  const content = getStepContent();
+
+  return (
+    <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/50 backdrop-blur-sm p-4">
+      <div className="bg-white dark:bg-gray-800 rounded-xl w-full max-w-md shadow-2xl border border-gray-200 dark:border-gray-700 max-h-[80vh] sm:max-h-[90vh] flex flex-col">
+        <div className="flex justify-between items-center p-4 sm:p-6 pb-3 sm:pb-4 border-b border-gray-200 dark:border-gray-700 flex-shrink-0">
+          <h2 className="text-lg font-semibold text-gray-900 dark:text-gray-100">
+            {isError ? 'Error' : content.title}
+          </h2>
+          <button
+            onClick={onClose}
+            className="text-gray-400 hover:text-gray-600 dark:hover:text-gray-300 transition-colors"
+          >
+            <svg
+              className="w-6 h-6"
+              fill="none"
+              stroke="currentColor"
+              viewBox="0 0 24 24"
+            >
+              <path
+                strokeLinecap="round"
+                strokeLinejoin="round"
+                strokeWidth={2}
+                d="M6 18L18 6M6 6l12 12"
+              />
+            </svg>
+          </button>
+        </div>
+
+        <div className="flex-1 overflow-y-auto p-4 sm:p-6 pt-3 sm:pt-4 min-h-0">
+          {isError ? (
+            <div className="text-center">
+              <div className="text-red-600 dark:text-red-400 mb-4">
+                {error?.message || 'Unknown error, please try again.'}
+              </div>
+            </div>
+          ) : (
+            <div className="text-center">
+              <div className="mb-6">
+                {typeof content.description === 'string' ? (
+                  <p className="text-gray-600 dark:text-gray-400">
+                    {content.description}
+                  </p>
+                ) : (
+                  content.description
+                )}
+              </div>
+
+              <div className="mb-6 flex justify-center">
+                {content.showQR && content.qrUrl ? (
+                  <div className="p-4 bg-white rounded-lg">
+                    {/* eslint-disable-next-line @next/next/no-img-element */}
+                    <img
+                      src={`https://api.qrserver.com/v1/create-qr-code/?size=200x200&data=${encodeURIComponent(
+                        content.qrUrl
+                      )}`}
+                      alt="QR Code"
+                      className="w-48 h-48"
+                    />
+                  </div>
+                ) : step === 'loading' || isLoading ? (
+                  <div className="w-48 h-48 flex items-center justify-center bg-gray-50 dark:bg-gray-700 rounded-lg">
+                    <div className="flex flex-col items-center gap-3">
+                      <div className="spinner w-8 h-8" />
+                      <span className="text-sm text-gray-500 dark:text-gray-400">
+                        {step === 'loading'
+                          ? 'Setting up access...'
+                          : 'Loading...'}
+                      </span>
+                    </div>
+                  </div>
+                ) : null}
+              </div>
+
+              {content.showOpenButton && content.qrUrl && (
+                <button
+                  onClick={() => {
+                    if (content.qrUrl) {
+                      window.open(
+                        content.qrUrl
+                          .replace(
+                            'https://farcaster.xyz/',
+                            'https://client.farcaster.xyz/deeplinks/'
+                          )
+                          .replace(
+                            'https://client.farcaster.xyz/deeplinks/signed-key-request',
+                            'https://farcaster.xyz/~/connect'
+                          ),
+                        '_blank'
+                      )
+                    }
+                  }}
+                  className="btn btn-outline flex items-center justify-center gap-2 w-full"
+                >
+                  I&apos;m using my phone →
+                </button>
+              )}
+            </div>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}

src/components/ui/NeynarAuthButton/ProfileButton.tsx

@@ -0,0 +1,92 @@
+'use client';
+
+import { useRef, useState } from 'react';
+import { useDetectClickOutside } from '~/hooks/useDetectClickOutside';
+import { cn } from '~/lib/utils';
+
+export function ProfileButton({
+  userData,
+  onSignOut,
+}: {
+  userData?: { fid?: number; pfpUrl?: string; username?: string };
+  onSignOut: () => void;
+}) {
+  const [showDropdown, setShowDropdown] = useState(false);
+  const ref = useRef<HTMLDivElement>(null);
+
+  useDetectClickOutside(ref, () => setShowDropdown(false));
+
+  const name = userData?.username ?? `!${userData?.fid}`;
+  const pfpUrl = userData?.pfpUrl ?? 'https://farcaster.xyz/avatar.png';
+
+  return (
+    <div className="relative" ref={ref}>
+      <button
+        onClick={() => setShowDropdown(!showDropdown)}
+        className={cn(
+          'flex items-center gap-3 px-4 py-2 min-w-0 rounded-lg',
+          'bg-transparent border border-gray-300 dark:border-gray-600 text-gray-900 dark:text-gray-100',
+          'hover:bg-gray-100 dark:hover:bg-gray-700 transition-colors',
+          'focus:outline-none focus:ring-1 focus:ring-primary'
+        )}
+      >
+        {/* eslint-disable-next-line @next/next/no-img-element */}
+        <img
+          src={pfpUrl}
+          alt="Profile"
+          className="w-6 h-6 rounded-full object-cover flex-shrink-0"
+          onError={(e) => {
+            (e.target as HTMLImageElement).src =
+              'https://farcaster.xyz/avatar.png';
+          }}
+        />
+        <span className="text-sm font-medium truncate max-w-[120px]">
+          {name ? name : '...'}
+        </span>
+        <svg
+          className={cn(
+            'w-4 h-4 transition-transform flex-shrink-0',
+            showDropdown && 'rotate-180'
+          )}
+          fill="none"
+          stroke="currentColor"
+          viewBox="0 0 24 24"
+        >
+          <path
+            strokeLinecap="round"
+            strokeLinejoin="round"
+            strokeWidth={2}
+            d="M19 9l-7 7-7-7"
+          />
+        </svg>
+      </button>
+
+      {showDropdown && (
+        <div className="absolute top-full right-0 left-0 mt-1 w-48 bg-white dark:bg-gray-800 rounded-lg shadow-lg border border-gray-200 dark:border-gray-700 z-50">
+          <button
+            onClick={() => {
+              onSignOut();
+              setShowDropdown(false);
+            }}
+            className="w-full px-4 py-3 text-left text-sm text-gray-700 dark:text-gray-300 hover:bg-gray-50 dark:hover:bg-gray-700 flex items-center gap-3 rounded-lg transition-colors"
+          >
+            <svg
+              className="w-4 h-4"
+              fill="none"
+              stroke="currentColor"
+              viewBox="0 0 24 24"
+            >
+              <path
+                strokeLinecap="round"
+                strokeLinejoin="round"
+                strokeWidth={1.5}
+                d="M17 16l4-4m0 0l-4-4m4 4H7m6 4v1a3 3 0 01-3 3H6a3 3 0 01-3-3V7a3 3 0 013-3h4a3 3 0 013 3v1"
+              />
+            </svg>
+            Sign out
+          </button>
+        </div>
+      )}
+    </div>
+  );
+}

src/components/ui/NeynarAuthButton/index.tsx

@@ -0,0 +1,705 @@
+'use client';
+
+import '@farcaster/auth-kit/styles.css';
+import { useSignIn, UseSignInData } from '@farcaster/auth-kit';
+import { useCallback, useEffect, useState, useRef } from 'react';
+import { cn } from '~/lib/utils';
+import { Button } from '~/components/ui/Button';
+import { ProfileButton } from '~/components/ui/NeynarAuthButton/ProfileButton';
+import { AuthDialog } from '~/components/ui/NeynarAuthButton/AuthDialog';
+import { getItem, removeItem, setItem } from '~/lib/localStorage';
+import { useMiniApp } from '@neynar/react';
+import {
+  signIn as backendSignIn,
+  signOut as backendSignOut,
+  useSession,
+} from 'next-auth/react';
+import sdk, { SignIn as SignInCore } from '@farcaster/frame-sdk';
+
+type User = {
+  fid: number;
+  username: string;
+  display_name: string;
+  pfp_url: string;
+  // Add other user properties as needed
+};
+
+const STORAGE_KEY = 'neynar_authenticated_user';
+const FARCASTER_FID = 9152;
+
+interface StoredAuthState {
+  isAuthenticated: boolean;
+  user: {
+    object: 'user';
+    fid: number;
+    username: string;
+    display_name: string;
+    pfp_url: string;
+    custody_address: string;
+    profile: {
+      bio: {
+        text: string;
+        mentioned_profiles?: Array<{
+          object: 'user_dehydrated';
+          fid: number;
+          username: string;
+          display_name: string;
+          pfp_url: string;
+          custody_address: string;
+        }>;
+        mentioned_profiles_ranges?: Array<{
+          start: number;
+          end: number;
+        }>;
+      };
+      location?: {
+        latitude: number;
+        longitude: number;
+        address: {
+          city: string;
+          state: string;
+          country: string;
+          country_code: string;
+        };
+      };
+    };
+    follower_count: number;
+    following_count: number;
+    verifications: string[];
+    verified_addresses: {
+      eth_addresses: string[];
+      sol_addresses: string[];
+      primary: {
+        eth_address: string;
+        sol_address: string;
+      };
+    };
+    verified_accounts: Array<Record<string, unknown>>;
+    power_badge: boolean;
+    url?: string;
+    experimental?: {
+      neynar_user_score: number;
+      deprecation_notice: string;
+    };
+    score: number;
+  } | null;
+  signers: {
+    object: 'signer';
+    signer_uuid: string;
+    public_key: string;
+    status: 'approved';
+    fid: number;
+  }[];
+}
+
+// Main Custom SignInButton Component
+export function NeynarAuthButton() {
+  const [nonce, setNonce] = useState<string | null>(null);
+  const [storedAuth, setStoredAuth] = useState<StoredAuthState | null>(null);
+  const [signersLoading, setSignersLoading] = useState(false);
+  const { context } = useMiniApp();
+  const { data: session } = useSession();
+  // New state for unified dialog flow
+  const [showDialog, setShowDialog] = useState(false);
+  const [dialogStep, setDialogStep] = useState<'signin' | 'access' | 'loading'>(
+    'loading'
+  );
+  const [signerApprovalUrl, setSignerApprovalUrl] = useState<string | null>(
+    null
+  );
+  const [pollingInterval, setPollingInterval] = useState<NodeJS.Timeout | null>(
+    null
+  );
+  const [message, setMessage] = useState<string | null>(null);
+  const [signature, setSignature] = useState<string | null>(null);
+  const [isSignerFlowRunning, setIsSignerFlowRunning] = useState(false);
+  const signerFlowStartedRef = useRef(false);
+
+  // Determine which flow to use based on context
+  const useBackendFlow = context !== undefined;
+
+  // Helper function to create a signer
+  const createSigner = useCallback(async () => {
+    try {
+      const response = await fetch('/api/auth/signer', {
+        method: 'POST',
+      });
+
+      if (!response.ok) {
+        throw new Error('Failed to create signer');
+      }
+
+      const signerData = await response.json();
+      return signerData;
+    } catch (error) {
+      console.error('❌ Error creating signer:', error);
+      // throw error;
+    }
+  }, []);
+
+  // Helper function to update session with signers (backend flow only)
+  const updateSessionWithSigners = useCallback(
+    async (
+      signers: StoredAuthState['signers'],
+      user: StoredAuthState['user']
+    ) => {
+      if (!useBackendFlow) return;
+
+      try {
+        // For backend flow, we need to sign in again with the additional data
+        if (message && signature) {
+          const signInData = {
+            message,
+            signature,
+            redirect: false,
+            nonce: nonce || '',
+            fid: user?.fid?.toString() || '',
+            signers: JSON.stringify(signers),
+            user: JSON.stringify(user),
+          };
+
+          await backendSignIn('neynar', signInData);
+        }
+      } catch (error) {
+        console.error('❌ Error updating session with signers:', error);
+      }
+    },
+    [useBackendFlow, message, signature, nonce]
+  );
+
+  // Helper function to fetch user data from Neynar API
+  const fetchUserData = useCallback(
+    async (fid: number): Promise<User | null> => {
+      try {
+        const response = await fetch(`/api/users?fids=${fid}`);
+        if (response.ok) {
+          const data = await response.json();
+          return data.users?.[0] || null;
+        }
+        return null;
+      } catch (error) {
+        console.error('Error fetching user data:', error);
+        return null;
+      }
+    },
+    []
+  );
+
+  // Helper function to generate signed key request
+  const generateSignedKeyRequest = useCallback(
+    async (signerUuid: string, publicKey: string) => {
+      try {
+        // Prepare request body
+        const requestBody: {
+          signerUuid: string;
+          publicKey: string;
+          sponsor?: { sponsored_by_neynar: boolean };
+        } = {
+          signerUuid,
+          publicKey,
+        };
+
+        const response = await fetch('/api/auth/signer/signed_key', {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify(requestBody),
+        });
+
+        if (!response.ok) {
+          const errorData = await response.json();
+          throw new Error(
+            `Failed to generate signed key request: ${errorData.error}`
+          );
+        }
+
+        const data = await response.json();
+
+        return data;
+      } catch (error) {
+        console.error('❌ Error generating signed key request:', error);
+        // throw error;
+      }
+    },
+    []
+  );
+
+  // Helper function to fetch all signers
+  const fetchAllSigners = useCallback(
+    async (message: string, signature: string) => {
+      try {
+        setSignersLoading(true);
+
+        const endpoint = useBackendFlow
+          ? `/api/auth/session-signers?message=${encodeURIComponent(
+              message
+            )}&signature=${signature}`
+          : `/api/auth/signers?message=${encodeURIComponent(
+              message
+            )}&signature=${signature}`;
+
+        const response = await fetch(endpoint);
+        const signerData = await response.json();
+
+        if (response.ok) {
+          if (useBackendFlow) {
+            // For backend flow, update session with signers
+            if (signerData.signers && signerData.signers.length > 0) {
+              const user =
+                signerData.user ||
+                (await fetchUserData(signerData.signers[0].fid));
+              await updateSessionWithSigners(signerData.signers, user);
+            }
+            return signerData.signers;
+          } else {
+            // For frontend flow, store in localStorage
+            let user: StoredAuthState['user'] | null = null;
+
+            if (signerData.signers && signerData.signers.length > 0) {
+              const fetchedUser = (await fetchUserData(
+                signerData.signers[0].fid
+              )) as StoredAuthState['user'];
+              user = fetchedUser;
+            }
+
+            // Store signers in localStorage, preserving existing auth data
+            const updatedState: StoredAuthState = {
+              isAuthenticated: !!user,
+              signers: signerData.signers || [],
+              user,
+            };
+            setItem<StoredAuthState>(STORAGE_KEY, updatedState);
+            setStoredAuth(updatedState);
+
+            return signerData.signers;
+          }
+        } else {
+          console.error('❌ Failed to fetch signers');
+          // throw new Error('Failed to fetch signers');
+        }
+      } catch (error) {
+        console.error('❌ Error fetching signers:', error);
+        // throw error;
+      } finally {
+        setSignersLoading(false);
+      }
+    },
+    [useBackendFlow, fetchUserData, updateSessionWithSigners]
+  );
+
+  // Helper function to poll signer status
+  const startPolling = useCallback(
+    (signerUuid: string, message: string, signature: string) => {
+      // Clear any existing polling interval before starting a new one
+      if (pollingInterval) {
+        clearInterval(pollingInterval);
+      }
+
+      let retryCount = 0;
+      const maxRetries = 10; // Maximum 10 retries (20 seconds total)
+      const maxPollingTime = 60000; // Maximum 60 seconds of polling
+      const startTime = Date.now();
+
+      const interval = setInterval(async () => {
+        // Check if we've been polling too long
+        if (Date.now() - startTime > maxPollingTime) {
+          clearInterval(interval);
+          setPollingInterval(null);
+          return;
+        }
+        
+        try {
+          const response = await fetch(
+            `/api/auth/signer?signerUuid=${signerUuid}`
+          );
+
+          if (!response.ok) {
+            // Check if it's a rate limit error
+            if (response.status === 429) {
+              clearInterval(interval);
+              setPollingInterval(null);
+              return;
+            }
+            
+            // Increment retry count for other errors
+            retryCount++;
+            if (retryCount >= maxRetries) {
+              clearInterval(interval);
+              setPollingInterval(null);
+              return;
+            }
+            
+            throw new Error(`Failed to poll signer status: ${response.status}`);
+          }
+
+          const signerData = await response.json();
+
+          if (signerData.status === 'approved') {
+            clearInterval(interval);
+            setPollingInterval(null);
+            setShowDialog(false);
+            setDialogStep('signin');
+            setSignerApprovalUrl(null);
+
+            // Refetch all signers
+            await fetchAllSigners(message, signature);
+          }
+        } catch (error) {
+          console.error('❌ Error polling signer:', error);
+        }
+      }, 2000); // Poll every 2 second
+
+      setPollingInterval(interval);
+    },
+    [fetchAllSigners, pollingInterval]
+  );
+
+  // Cleanup polling on unmount
+  useEffect(() => {
+    return () => {
+      if (pollingInterval) {
+        clearInterval(pollingInterval);
+      }
+      signerFlowStartedRef.current = false;
+    };
+  }, [pollingInterval]);
+
+  // Generate nonce
+  useEffect(() => {
+    const generateNonce = async () => {
+      try {
+        const response = await fetch('/api/auth/nonce');
+        if (response.ok) {
+          const data = await response.json();
+          setNonce(data.nonce);
+        } else {
+          console.error('Failed to fetch nonce');
+        }
+      } catch (error) {
+        console.error('Error generating nonce:', error);
+      }
+    };
+
+    generateNonce();
+  }, []);
+
+  // Load stored auth state on mount (only for frontend flow)
+  useEffect(() => {
+    if (!useBackendFlow) {
+      const stored = getItem<StoredAuthState>(STORAGE_KEY);
+      if (stored && stored.isAuthenticated) {
+        setStoredAuth(stored);
+      }
+    }
+  }, [useBackendFlow]);
+
+  // Success callback - this is critical!
+  const onSuccessCallback = useCallback(
+    async (res: UseSignInData) => {
+      if (!useBackendFlow) {
+        // Only handle localStorage for frontend flow
+        const existingAuth = getItem<StoredAuthState>(STORAGE_KEY);
+        const user = res.fid ? await fetchUserData(res.fid) : null;
+        const authState: StoredAuthState = {
+          ...existingAuth,
+          isAuthenticated: true,
+          user: user as StoredAuthState['user'],
+          signers: existingAuth?.signers || [], // Preserve existing signers
+        };
+        setItem<StoredAuthState>(STORAGE_KEY, authState);
+        setStoredAuth(authState);
+      }
+      // For backend flow, the session will be handled by NextAuth
+    },
+    [useBackendFlow, fetchUserData]
+  );
+
+  // Error callback
+  const onErrorCallback = useCallback((error?: Error | null) => {
+    console.error('❌ Sign in error:', error);
+  }, []);
+
+  const signInState = useSignIn({
+    nonce: nonce || undefined,
+    onSuccess: onSuccessCallback,
+    onError: onErrorCallback,
+  });
+
+  const {
+    signIn: frontendSignIn,
+    signOut: frontendSignOut,
+    connect,
+    reconnect,
+    isSuccess,
+    isError,
+    error,
+    channelToken,
+    url,
+    data,
+    validSignature,
+  } = signInState;
+
+  useEffect(() => {
+    setMessage(data?.message || null);
+    setSignature(data?.signature || null);
+    
+    // Reset the signer flow flag when message/signature change
+    if (data?.message && data?.signature) {
+      signerFlowStartedRef.current = false;
+    }
+  }, [data?.message, data?.signature]);
+
+  // Connect for frontend flow when nonce is available
+  useEffect(() => {
+    if (!useBackendFlow && nonce && !channelToken) {
+      connect();
+    }
+  }, [useBackendFlow, nonce, channelToken, connect]);
+
+  // Handle fetching signers after successful authentication
+  useEffect(() => {
+    if (message && signature && !isSignerFlowRunning && !signerFlowStartedRef.current) {
+      signerFlowStartedRef.current = true;
+      
+      const handleSignerFlow = async () => {
+        setIsSignerFlowRunning(true);
+        try {
+          const clientContext = context?.client as Record<string, unknown>;
+          const isMobileContext =
+            clientContext?.platformType === 'mobile' &&
+            clientContext?.clientFid === FARCASTER_FID;
+
+          // Step 1: Change to loading state
+          setDialogStep('loading');
+
+          // Show dialog if not using backend flow or in browser farcaster
+          if ((useBackendFlow && !isMobileContext) || !useBackendFlow)
+            setShowDialog(true);
+
+          // First, fetch existing signers
+          const signers = await fetchAllSigners(message, signature);
+          
+          if (useBackendFlow && isMobileContext) setSignersLoading(true);
+
+          // Check if no signers exist or if we have empty signers
+          if (!signers || signers.length === 0) {
+            // Step 1: Create a signer
+            const newSigner = await createSigner();
+
+            // Step 2: Generate signed key request
+            const signedKeyData = await generateSignedKeyRequest(
+              newSigner.signer_uuid,
+              newSigner.public_key
+            );
+
+            // Step 3: Show QR code in access dialog for signer approval
+            setSignerApprovalUrl(signedKeyData.signer_approval_url);
+
+            if (isMobileContext) {
+              setShowDialog(false);
+              await sdk.actions.openUrl(
+                signedKeyData.signer_approval_url.replace(
+                  'https://client.farcaster.xyz/deeplinks/signed-key-request',
+                  'https://farcaster.xyz/~/connect'
+                )
+              );
+            } else {
+              setShowDialog(true); // Ensure dialog is shown during loading
+              setDialogStep('access');
+            }
+
+            // Step 4: Start polling for signer approval
+            startPolling(newSigner.signer_uuid, message, signature);
+          } else {
+            // If signers exist, close the dialog
+            setSignersLoading(false);
+            setShowDialog(false);
+            setDialogStep('signin');
+          }
+        } catch (error) {
+          console.error('❌ Error in signer flow:', error);
+          // On error, reset to signin step and hide dialog
+          setDialogStep('signin');
+          setSignersLoading(false);
+          setShowDialog(false);
+          setSignerApprovalUrl(null);
+        } finally {
+          setIsSignerFlowRunning(false);
+        }
+      };
+
+      handleSignerFlow();
+    }
+  }, [message, signature]); // Simplified dependencies
+
+  // Backend flow using NextAuth
+  const handleBackendSignIn = useCallback(async () => {
+    if (!nonce) {
+      console.error('❌ No nonce available for backend sign-in');
+      return;
+    }
+
+    try {
+      setSignersLoading(true);
+      const result = await sdk.actions.signIn({ nonce });
+
+      const signInData = {
+        message: result.message,
+        signature: result.signature,
+        redirect: false,
+        nonce: nonce,
+      };
+
+      const nextAuthResult = await backendSignIn('neynar', signInData);
+      if (nextAuthResult?.ok) {
+        setMessage(result.message);
+        setSignature(result.signature);
+      } else {
+        console.error('❌ NextAuth sign-in failed:', nextAuthResult);
+      }
+    } catch (e) {
+      if (e instanceof SignInCore.RejectedByUser) {
+        console.log('ℹ️ Sign-in rejected by user');
+      } else {
+        console.error('❌ Backend sign-in error:', e);
+      }
+    }
+  }, [nonce]);
+
+  const handleFrontEndSignIn = useCallback(() => {
+    if (isError) {
+      reconnect();
+    }
+    setDialogStep('signin');
+    setShowDialog(true);
+    frontendSignIn();
+  }, [isError, reconnect, frontendSignIn]);
+
+  const handleSignOut = useCallback(async () => {
+    try {
+      setSignersLoading(true);
+
+      if (useBackendFlow) {
+        // Only sign out from NextAuth if the current session is from Neynar provider
+        if (session?.provider === 'neynar') {
+          await backendSignOut({ redirect: false });
+        }
+      } else {
+        // Frontend flow sign out
+        frontendSignOut();
+        removeItem(STORAGE_KEY);
+        setStoredAuth(null);
+      }
+
+      // Common cleanup for both flows
+      setShowDialog(false);
+      setDialogStep('signin');
+      setSignerApprovalUrl(null);
+      setMessage(null);
+      setSignature(null);
+
+      // Reset polling interval
+      if (pollingInterval) {
+        clearInterval(pollingInterval);
+        setPollingInterval(null);
+      }
+      
+      // Reset signer flow flag
+      signerFlowStartedRef.current = false;
+    } catch (error) {
+      console.error('❌ Error during sign out:', error);
+      // Optionally handle error state
+    } finally {
+      setSignersLoading(false);
+    }
+  }, [useBackendFlow, frontendSignOut, pollingInterval, session]);
+
+  const authenticated = useBackendFlow
+    ? !!(
+        session?.provider === 'neynar' &&
+        session?.user?.fid &&
+        session?.signers &&
+        session.signers.length > 0
+      )
+    : ((isSuccess && validSignature) || storedAuth?.isAuthenticated) &&
+      !!(storedAuth?.signers && storedAuth.signers.length > 0);
+
+  const userData = useBackendFlow
+    ? {
+        fid: session?.user?.fid,
+        username: session?.user?.username || '',
+        pfpUrl: session?.user?.pfp_url || '',
+      }
+    : {
+        fid: storedAuth?.user?.fid,
+        username: storedAuth?.user?.username || '',
+        pfpUrl: storedAuth?.user?.pfp_url || '',
+      };
+
+  // Show loading state while nonce is being fetched or signers are loading
+  if (!nonce || signersLoading) {
+    return (
+      <div className="flex items-center justify-center">
+        <div className="flex items-center gap-3 px-4 py-2 bg-gray-100 dark:bg-gray-800 rounded-lg">
+          <div className="spinner w-4 h-4" />
+          <span className="text-sm text-gray-600 dark:text-gray-400">
+            Loading...
+          </span>
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <>
+      {authenticated ? (
+        <ProfileButton userData={userData} onSignOut={handleSignOut} />
+      ) : (
+        <Button
+          onClick={useBackendFlow ? handleBackendSignIn : handleFrontEndSignIn}
+          disabled={!useBackendFlow && !url}
+          className={cn(
+            'btn btn-primary flex items-center gap-3',
+            'disabled:opacity-50 disabled:cursor-not-allowed',
+            'transform transition-all duration-200 active:scale-[0.98]',
+            !url && !useBackendFlow && 'cursor-not-allowed'
+          )}
+        >
+          {!useBackendFlow && !url ? (
+            <>
+              <div className="spinner-primary w-5 h-5" />
+              <span>Initializing...</span>
+            </>
+          ) : (
+            <>
+              <span>Sign in with Neynar</span>
+            </>
+          )}
+        </Button>
+      )}
+
+      {/* Unified Auth Dialog */}
+      {
+        <AuthDialog
+          open={showDialog}
+          onClose={() => {
+            setShowDialog(false);
+            setDialogStep('signin');
+            setSignerApprovalUrl(null);
+            if (pollingInterval) {
+              clearInterval(pollingInterval);
+              setPollingInterval(null);
+            }
+          }}
+          url={url}
+          isError={isError}
+          error={error}
+          step={dialogStep}
+          isLoading={signersLoading}
+          signerApprovalUrl={signerApprovalUrl}
+        />
+      }
+    </>
+  );
+}

src/components/ui/tabs/ActionsTab.tsx

@@ -1,4 +1,4 @@
-"use client";
+'use client';
 
 import { useCallback, useState } from "react";
 import { useMiniApp } from "@neynar/react";
@@ -7,10 +7,11 @@ import { Button } from "../Button";
 import { SignIn } from "../wallet/SignIn";
 import { type Haptics } from "@farcaster/miniapp-sdk";
 import { APP_URL } from "~/lib/constants";
+import { NeynarAuthButton } from '../NeynarAuthButton/index';
 
 /**
  * ActionsTab component handles mini app actions like sharing, notifications, and haptic feedback.
- * 
+ *
  * This component provides the main interaction interface for users to:
  * - Share the mini app with others
  * - Sign in with Farcaster
@@ -18,10 +19,10 @@ import { APP_URL } from "~/lib/constants";
  * - Trigger haptic feedback
  * - Add the mini app to their client
  * - Copy share URLs
- * 
+ *
  * The component uses the useMiniApp hook to access Farcaster context and actions.
  * All state is managed locally within this component.
- * 
+ *
  * @example
  * ```tsx
  * <ActionsTab />
@@ -29,63 +30,68 @@ import { APP_URL } from "~/lib/constants";
  */
 export function ActionsTab() {
   // --- Hooks ---
-  const {
-    actions,
-    added,
-    notificationDetails,
-    haptics,
-    context,
-  } = useMiniApp();
-  
+  const { actions, added, notificationDetails, haptics, context } =
+    useMiniApp();
+
   // --- State ---
   const [notificationState, setNotificationState] = useState({
-    sendStatus: "",
+    sendStatus: '',
     shareUrlCopied: false,
   });
-  const [selectedHapticIntensity, setSelectedHapticIntensity] = useState<Haptics.ImpactOccurredType>('medium');
+  const [selectedHapticIntensity, setSelectedHapticIntensity] =
+    useState<Haptics.ImpactOccurredType>('medium');
 
   // --- Handlers ---
   /**
    * Sends a notification to the current user's Farcaster account.
-   * 
+   *
    * This function makes a POST request to the /api/send-notification endpoint
    * with the user's FID and notification details. It handles different response
    * statuses including success (200), rate limiting (429), and errors.
-   * 
+   *
    * @returns Promise that resolves when the notification is sent or fails
    */
   const sendFarcasterNotification = useCallback(async () => {
-    setNotificationState((prev) => ({ ...prev, sendStatus: "" }));
+    setNotificationState((prev) => ({ ...prev, sendStatus: '' }));
     if (!notificationDetails || !context) {
       return;
     }
     try {
-      const response = await fetch("/api/send-notification", {
-        method: "POST",
-        mode: "same-origin",
-        headers: { "Content-Type": "application/json" },
+      const response = await fetch('/api/send-notification', {
+        method: 'POST',
+        mode: 'same-origin',
+        headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({
           fid: context.user.fid,
           notificationDetails,
         }),
       });
       if (response.status === 200) {
-        setNotificationState((prev) => ({ ...prev, sendStatus: "Success" }));
+        setNotificationState((prev) => ({ ...prev, sendStatus: 'Success' }));
         return;
       } else if (response.status === 429) {
-        setNotificationState((prev) => ({ ...prev, sendStatus: "Rate limited" }));
+        setNotificationState((prev) => ({
+          ...prev,
+          sendStatus: 'Rate limited',
+        }));
         return;
       }
       const responseText = await response.text();
-      setNotificationState((prev) => ({ ...prev, sendStatus: `Error: ${responseText}` }));
+      setNotificationState((prev) => ({
+        ...prev,
+        sendStatus: `Error: ${responseText}`,
+      }));
     } catch (error) {
-      setNotificationState((prev) => ({ ...prev, sendStatus: `Error: ${error}` }));
+      setNotificationState((prev) => ({
+        ...prev,
+        sendStatus: `Error: ${error}`,
+      }));
     }
   }, [context, notificationDetails]);
 
   /**
    * Copies the share URL for the current user to the clipboard.
-   * 
+   *
    * This function generates a share URL using the user's FID and copies it
    * to the clipboard. It shows a temporary "Copied!" message for 2 seconds.
    */
@@ -94,13 +100,17 @@ export function ActionsTab() {
       const userShareUrl = `${APP_URL}/share/${context.user.fid}`;
       await navigator.clipboard.writeText(userShareUrl);
       setNotificationState((prev) => ({ ...prev, shareUrlCopied: true }));
-      setTimeout(() => setNotificationState((prev) => ({ ...prev, shareUrlCopied: false })), 2000);
+      setTimeout(
+        () =>
+          setNotificationState((prev) => ({ ...prev, shareUrlCopied: false })),
+        2000
+      );
     }
   }, [context?.user?.fid]);
 
   /**
    * Triggers haptic feedback with the selected intensity.
-   * 
+   *
    * This function calls the haptics.impactOccurred method with the current
    * selectedHapticIntensity setting. It handles errors gracefully by logging them.
    */
@@ -114,56 +124,74 @@ export function ActionsTab() {
 
   // --- Render ---
   return (
-    <div className="space-y-3 px-6 w-full max-w-md mx-auto">
+    <div className='space-y-3 px-6 w-full max-w-md mx-auto'>
       {/* Share functionality */}
-      <ShareButton 
-        buttonText="Share Mini App"
+      <ShareButton
+        buttonText='Share Mini App'
         cast={{
-          text: "Check out this awesome frame @1 @2 @3! 🚀🪐",
+          text: 'Check out this awesome frame @1 @2 @3! 🚀🪐',
           bestFriends: true,
           embeds: [`${APP_URL}/share/${context?.user?.fid || ''}`]
         }}
-        className="w-full"
+        className='w-full'
       />
 
       {/* Authentication */}
       <SignIn />
 
-      {/* Mini app actions */}
-      <Button onClick={() => actions.openUrl("https://www.youtube.com/watch?v=dQw4w9WgXcQ")} className="w-full">Open Link</Button>
+      {/* Neynar Authentication */}
+      <NeynarAuthButton />
 
-      <Button onClick={actions.addMiniApp} disabled={added} className="w-full">
+      {/* Mini app actions */}
+      <Button
+        onClick={() =>
+          actions.openUrl('https://www.youtube.com/watch?v=dQw4w9WgXcQ')
+        }
+        className='w-full'
+      >
+        Open Link
+      </Button>
+
+      <Button onClick={actions.addMiniApp} disabled={added} className='w-full'>
         Add Mini App to Client
       </Button>
 
       {/* Notification functionality */}
       {notificationState.sendStatus && (
-        <div className="text-sm w-full">
+        <div className='text-sm w-full'>
           Send notification result: {notificationState.sendStatus}
         </div>
       )}
-      <Button onClick={sendFarcasterNotification} disabled={!notificationDetails} className="w-full">
+      <Button
+        onClick={sendFarcasterNotification}
+        disabled={!notificationDetails}
+        className='w-full'
+      >
         Send notification
       </Button>
 
       {/* Share URL copying */}
-      <Button 
+      <Button
         onClick={copyUserShareUrl}
         disabled={!context?.user?.fid}
-        className="w-full"
+        className='w-full'
       >
-        {notificationState.shareUrlCopied ? "Copied!" : "Copy share URL"}
+        {notificationState.shareUrlCopied ? 'Copied!' : 'Copy share URL'}
       </Button>
 
       {/* Haptic feedback controls */}
-      <div className="space-y-2">
-        <label className="block text-sm font-medium text-gray-700 dark:text-gray-300">
+      <div className='space-y-2'>
+        <label className='block text-sm font-medium text-gray-700 dark:text-gray-300'>
           Haptic Intensity
         </label>
         <select
           value={selectedHapticIntensity}
-          onChange={(e) => setSelectedHapticIntensity(e.target.value as Haptics.ImpactOccurredType)}
-          className="w-full px-3 py-2 border border-gray-300 dark:border-gray-600 rounded-md bg-white dark:bg-gray-800 text-gray-900 dark:text-gray-100 focus:outline-none focus:ring-2 focus:ring-primary"
+          onChange={(e) =>
+            setSelectedHapticIntensity(
+              e.target.value as Haptics.ImpactOccurredType
+            )
+          }
+          className='w-full px-3 py-2 border border-gray-300 dark:border-gray-600 rounded-md bg-white dark:bg-gray-800 text-gray-900 dark:text-gray-100 focus:outline-none focus:ring-2 focus:ring-primary'
         >
           <option value={'light'}>Light</option>
           <option value={'medium'}>Medium</option>
@@ -171,13 +199,10 @@ export function ActionsTab() {
           <option value={'soft'}>Soft</option>
           <option value={'rigid'}>Rigid</option>
         </select>
-        <Button 
-          onClick={triggerHapticFeedback}
-          className="w-full"
-        >
+        <Button onClick={triggerHapticFeedback} className='w-full'>
           Trigger Haptic Feedback
         </Button>
       </div>
     </div>
   );
-} 
+}

src/components/ui/wallet/SignIn.tsx

@@ -1,4 +1,4 @@
-"use client";
+'use client';
 
 import { useCallback, useState } from "react";
 import { signIn, signOut, getCsrfToken } from "next-auth/react";
@@ -8,17 +8,17 @@ import { Button } from "../Button";
 
 /**
  * SignIn component handles Farcaster authentication using Sign-In with Farcaster (SIWF).
- * 
+ *
  * This component provides a complete authentication flow for Farcaster users:
  * - Generates nonces for secure authentication
  * - Handles the SIWF flow using the Farcaster SDK
  * - Manages NextAuth session state
  * - Provides sign-out functionality
  * - Displays authentication status and results
- * 
+ *
  * The component integrates with both the Farcaster Frame SDK and NextAuth
  * to provide seamless authentication within mini apps.
- * 
+ *
  * @example
  * ```tsx
  * <SignIn />
@@ -45,29 +45,29 @@ export function SignIn() {
   // --- Handlers ---
   /**
    * Generates a nonce for the sign-in process.
-   * 
+   *
    * This function retrieves a CSRF token from NextAuth to use as a nonce
    * for the SIWF authentication flow. The nonce ensures the authentication
    * request is fresh and prevents replay attacks.
-   * 
+   *
    * @returns Promise<string> - The generated nonce token
    * @throws Error if unable to generate nonce
    */
   const getNonce = useCallback(async () => {
     const nonce = await getCsrfToken();
-    if (!nonce) throw new Error("Unable to generate nonce");
+    if (!nonce) throw new Error('Unable to generate nonce');
     return nonce;
   }, []);
 
   /**
    * Handles the sign-in process using Farcaster SDK.
-   * 
+   *
    * This function orchestrates the complete SIWF flow:
    * 1. Generates a nonce for security
    * 2. Calls the Farcaster SDK to initiate sign-in
    * 3. Submits the result to NextAuth for session management
    * 4. Handles various error conditions including user rejection
-   * 
+   *
    * @returns Promise<void>
    */
   const handleSignIn = useCallback(async () => {
@@ -77,17 +77,17 @@ export function SignIn() {
       const nonce = await getNonce();
       const result = await sdk.actions.signIn({ nonce });
       setSignInResult(result);
-      await signIn("credentials", {
+      await signIn('farcaster', {
         message: result.message,
         signature: result.signature,
         redirect: false,
       });
     } catch (e) {
       if (e instanceof SignInCore.RejectedByUser) {
-        setSignInFailure("Rejected by user");
+        setSignInFailure('Rejected by user');
         return;
       }
-      setSignInFailure("Unknown error");
+      setSignInFailure('Unknown error');
     } finally {
       setAuthState((prev) => ({ ...prev, signingIn: false }));
     }
@@ -95,32 +95,35 @@ export function SignIn() {
 
   /**
    * Handles the sign-out process.
-   * 
-   * This function clears the NextAuth session and resets the local
-   * sign-in result state to complete the sign-out flow.
-   * 
+   *
+   * This function clears the NextAuth session only if the current session
+   * is using the Farcaster provider, and resets the local sign-in result state.
+   *
    * @returns Promise<void>
    */
   const handleSignOut = useCallback(async () => {
     try {
       setAuthState((prev) => ({ ...prev, signingOut: true }));
-      await signOut({ redirect: false });
+      // Only sign out if the current session is from Farcaster provider
+      if (session?.provider === 'farcaster') {
+        await signOut({ redirect: false });
+      }
       setSignInResult(undefined);
     } finally {
       setAuthState((prev) => ({ ...prev, signingOut: false }));
     }
-  }, []);
+  }, [session]);
 
   // --- Render ---
   return (
     <>
       {/* Authentication Buttons */}
-      {status !== "authenticated" && (
+      {(status !== 'authenticated' || session?.provider !== 'farcaster') && (
         <Button onClick={handleSignIn} disabled={authState.signingIn}>
           Sign In with Farcaster
         </Button>
       )}
-      {status === "authenticated" && (
+      {status === 'authenticated' && session?.provider === 'farcaster' && (
         <Button onClick={handleSignOut} disabled={authState.signingOut}>
           Sign out
         </Button>
@@ -155,4 +158,4 @@ export function SignIn() {
       )}
     </>
   );
-} 
+}

src/hooks/useDetectClickOutside.ts

@@ -0,0 +1,18 @@
+import { useEffect } from 'react';
+
+export function useDetectClickOutside<T extends HTMLElement>(
+  ref: React.RefObject<T | null>,
+  callback: () => void
+) {
+  useEffect(() => {
+    function handleClickOutside(event: MouseEvent) {
+      if (ref.current && !ref.current.contains(event.target as Node)) {
+        callback();
+      }
+    }
+    document.addEventListener('mousedown', handleClickOutside);
+    return () => {
+      document.removeEventListener('mousedown', handleClickOutside);
+    };
+  }, [ref, callback]);
+}

src/lib/constants.ts

@@ -2,11 +2,11 @@ import { type AccountAssociation } from '@farcaster/miniapp-node';
 
 /**
  * Application constants and configuration values.
- * 
+ *
  * This file contains all the configuration constants used throughout the mini app.
  * These values are either sourced from environment variables or hardcoded and provide
  * configuration for the app's appearance, behavior, and integration settings.
- * 
+ *
  * NOTE: This file is automatically updated by the init script.
  * Manual changes may be overwritten during project initialization.
  */
@@ -84,7 +84,7 @@ export const APP_BUTTON_TEXT: string = 'Launch NSK';
 // --- Integration Configuration ---
 /**
  * Webhook URL for receiving events from Neynar.
- * 
+ *
  * If Neynar API key and client ID are configured, uses the official
  * Neynar webhook endpoint. Otherwise, falls back to a local webhook
  * endpoint for development and testing.
@@ -95,7 +95,7 @@ export const APP_WEBHOOK_URL: string = process.env.NEYNAR_API_KEY && process.env
 
 /**
  * Flag to enable/disable wallet functionality.
- * 
+ *
  * When true, wallet-related components and features are rendered.
  * When false, wallet functionality is completely hidden from the UI.
  * Useful for mini apps that don't require wallet integration.
@@ -104,9 +104,25 @@ export const USE_WALLET: boolean = true;
 
 /**
  * Flag to enable/disable analytics tracking.
- * 
+ *
  * When true, usage analytics are collected and sent to Neynar.
  * When false, analytics collection is disabled.
  * Useful for privacy-conscious users or development environments.
  */
 export const ANALYTICS_ENABLED: boolean = true;
+
+// PLEASE DO NOT UPDATE THIS
+export const SIGNED_KEY_REQUEST_VALIDATOR_EIP_712_DOMAIN = {
+  name: 'Farcaster SignedKeyRequestValidator',
+  version: '1',
+  chainId: 10,
+  verifyingContract:
+    '0x00000000fc700472606ed4fa22623acf62c60553' as `0x${string}`,
+};
+
+// PLEASE DO NOT UPDATE THIS
+export const SIGNED_KEY_REQUEST_TYPE = [
+  { name: 'requestFid', type: 'uint256' },
+  { name: 'key', type: 'bytes' },
+  { name: 'deadline', type: 'uint256' },
+];

src/lib/devices.ts

@@ -0,0 +1,27 @@
+function isAndroid(): boolean {
+  return (
+    typeof navigator !== 'undefined' && /android/i.test(navigator.userAgent)
+  );
+}
+
+function isSmallIOS(): boolean {
+  return (
+    typeof navigator !== 'undefined' && /iPhone|iPod/.test(navigator.userAgent)
+  );
+}
+
+function isLargeIOS(): boolean {
+  return (
+    typeof navigator !== 'undefined' &&
+    (/iPad/.test(navigator.userAgent) ||
+      (navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1))
+  );
+}
+
+function isIOS(): boolean {
+  return isSmallIOS() || isLargeIOS();
+}
+
+export function isMobile(): boolean {
+  return isAndroid() || isIOS();
+}

src/lib/localStorage.ts

@@ -0,0 +1,25 @@
+export function setItem<T>(key: string, value: T) {
+  try {
+    localStorage.setItem(key, JSON.stringify(value));
+  } catch (error) {
+    console.warn('Failed to save item:', error);
+  }
+}
+
+export function getItem<T>(key: string): T | null {
+  try {
+    const stored = localStorage.getItem(key);
+    return stored ? JSON.parse(stored) : null;
+  } catch (error) {
+    console.warn('Failed to load item:', error);
+    return null;
+  }
+}
+
+export function removeItem(key: string) {
+  try {
+    localStorage.removeItem(key);
+  } catch (error) {
+    console.warn('Failed to remove item:', error);
+  }
+}

src/lib/utils.ts

@@ -19,17 +19,6 @@ export function cn(...inputs: ClassValue[]) {
   return twMerge(clsx(inputs));
 }
 
-export function getSecretEnvVars() {
-  const seedPhrase = process.env.SEED_PHRASE;
-  const fid = process.env.FID;
-  
-  if (!seedPhrase || !fid) {
-    return null;
-  }
-
-  return { seedPhrase, fid };
-}
-
 export function getMiniAppEmbedMetadata(ogImageUrl?: string) {
   return {
     version: "next",