diff --git a/bin/init.js b/bin/init.js
index f177adf..a6cdee3 100644
--- a/bin/init.js
+++ b/bin/init.js
@@ -351,14 +351,7 @@ export async function init(projectName = null, autoAcceptDefaults = false, apiKe
         type: 'confirm',
         name: 'useSponsoredSigner',
         message:
-          'Would you like to use Neynar Sponsored Signers and/or Sign In With Neynar (SIWN)?\n' +
-          'This enables the simplest, most secure, and most user-friendly Farcaster authentication for your app.\n\n' +
-          'Benefits of using Neynar Sponsored Signers/SIWN:\n' +
-          '- No auth buildout or signer management required for developers\n' +
-          '- Cost-effective for users (no gas for signers)\n' +
-          '- Users can revoke signers at any time\n' +
-          '- Plug-and-play for web and React Native\n' +
-          '- Recommended for most developers\n' +
+          'Would you like to write data to Farcaster on behalf of your miniapp users? This involves using Neynar Sponsored Signers and SIWN.\n' +
           '\n⚠️ A seed phrase is required for this option.\n',
         default: false,
       },
@@ -453,13 +446,14 @@ export async function init(projectName = null, autoAcceptDefaults = false, apiKe
   delete packageJson.devDependencies;
 
   // Add dependencies
+  // question: remove auth-client?
   packageJson.dependencies = {
     '@farcaster/auth-client': '>=0.3.0 <1.0.0',
-    '@farcaster/auth-kit': '>=0.6.0 <1.0.0',
     '@farcaster/miniapp-node': '>=0.1.5 <1.0.0',
     '@farcaster/miniapp-sdk': '>=0.1.6 <1.0.0',
     '@farcaster/miniapp-wagmi-connector': '^1.0.0',
     '@farcaster/mini-app-solana': '>=0.0.17 <1.0.0',
+    '@farcaster/quick-auth': '>=0.0.7 <1.0.0',
     '@neynar/react': '^1.2.5',
     '@radix-ui/react-label': '^2.1.1',
     '@solana/wallet-adapter-react': '^0.15.38',
@@ -471,7 +465,6 @@ export async function init(projectName = null, autoAcceptDefaults = false, apiKe
     'lucide-react': '^0.469.0',
     mipd: '^0.0.7',
     next: '^15',
-    'next-auth': '^4.24.11',
     react: '^19',
     'react-dom': '^19',
     'tailwind-merge': '^2.6.0',
@@ -483,6 +476,7 @@ export async function init(projectName = null, autoAcceptDefaults = false, apiKe
   };
 
   packageJson.devDependencies = {
+    "@types/inquirer": "^9.0.8",
     "@types/node": "^20",
     "@types/react": "^19",
     "@types/react-dom": "^19",
@@ -494,8 +488,8 @@ export async function init(projectName = null, autoAcceptDefaults = false, apiKe
     "pino-pretty": "^13.0.0",
     "postcss": "^8",
     "tailwindcss": "^3.4.1",
-    "typescript": "^5",
-    "ts-node": "^10.9.2"
+    "ts-node": "^10.9.2",
+    "typescript": "^5"
   };
 
   // Add Neynar SDK if selected
@@ -503,6 +497,12 @@ export async function init(projectName = null, autoAcceptDefaults = false, apiKe
     packageJson.dependencies['@neynar/nodejs-sdk'] = '^2.19.0';
   }
 
+    // Add auth-kit and next-auth dependencies if useSponsoredSigner is true
+    if (answers.useSponsoredSigner) {
+      packageJson.dependencies['@farcaster/auth-kit'] = '>=0.6.0 <1.0.0';
+      packageJson.dependencies['next-auth'] = '^4.24.11';
+    }
+
   fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
 
   // Handle .env file
@@ -632,10 +632,7 @@ export async function init(projectName = null, autoAcceptDefaults = false, apiKe
       console.log('⚠️  constants.ts not found, skipping constants update');
     }
 
-    fs.appendFileSync(
-      envPath,
-      `\nNEXTAUTH_SECRET="${crypto.randomBytes(32).toString('hex')}"`
-    );
+    
     if (useNeynar && neynarApiKey && neynarClientId) {
       fs.appendFileSync(envPath, `\nNEYNAR_API_KEY="${neynarApiKey}"`);
       fs.appendFileSync(envPath, `\nNEYNAR_CLIENT_ID="${neynarClientId}"`);
@@ -648,6 +645,13 @@ export async function init(projectName = null, autoAcceptDefaults = false, apiKe
       fs.appendFileSync(envPath, `\nSEED_PHRASE="${answers.seedPhrase}"`);
     }
     fs.appendFileSync(envPath, `\nUSE_TUNNEL="${answers.useTunnel}"`);
+    if (answers.useSponsoredSigner) {
+      fs.appendFileSync(envPath, `\nSPONSOR_SIGNER="${answers.useSponsoredSigner}"`);
+      fs.appendFileSync(
+        envPath,
+        `\nNEXTAUTH_SECRET="${crypto.randomBytes(32).toString('hex')}"`
+      );
+    }
 
     fs.unlinkSync(envExamplePath);
   } else {
@@ -691,6 +695,42 @@ export async function init(projectName = null, autoAcceptDefaults = false, apiKe
     fs.rmSync(binPath, { recursive: true, force: true });
   }
 
+  // Remove NeynarAuthButton directory, NextAuth API routes, and auth directory if useSponsoredSigner is false
+  if (!answers.useSponsoredSigner) {
+    console.log('\nRemoving NeynarAuthButton directory, NextAuth API routes, and auth directory (useSponsoredSigner is false)...');
+    const neynarAuthButtonPath = path.join(projectPath, 'src', 'components', 'ui', 'NeynarAuthButton');
+    if (fs.existsSync(neynarAuthButtonPath)) {
+      fs.rmSync(neynarAuthButtonPath, { recursive: true, force: true });
+    }
+    
+    // Remove NextAuth API routes
+    const nextAuthRoutePath = path.join(projectPath, 'src', 'app', 'api', 'auth', '[...nextauth]', 'route.ts');
+    if (fs.existsSync(nextAuthRoutePath)) {
+      fs.rmSync(nextAuthRoutePath, { force: true });
+      // Remove the directory if it's empty
+      const nextAuthDir = path.dirname(nextAuthRoutePath);
+      if (fs.readdirSync(nextAuthDir).length === 0) {
+        fs.rmSync(nextAuthDir, { recursive: true, force: true });
+      }
+    }
+    
+    const updateSessionRoutePath = path.join(projectPath, 'src', 'app', 'api', 'auth', 'update-session', 'route.ts');
+    if (fs.existsSync(updateSessionRoutePath)) {
+      fs.rmSync(updateSessionRoutePath, { force: true });
+      // Remove the directory if it's empty
+      const updateSessionDir = path.dirname(updateSessionRoutePath);
+      if (fs.readdirSync(updateSessionDir).length === 0) {
+        fs.rmSync(updateSessionDir, { recursive: true, force: true });
+      }
+    }
+    
+    // Remove src/auth.ts file
+    const authFilePath = path.join(projectPath, 'src', 'auth.ts');
+    if (fs.existsSync(authFilePath)) {
+      fs.rmSync(authFilePath, { force: true });
+    }
+  }
+
   // Initialize git repository
   console.log('\nInitializing git repository...');
   execSync('git init', { cwd: projectPath });
diff --git a/scripts/deploy.ts b/scripts/deploy.ts
index cfc629d..fbbd792 100755
--- a/scripts/deploy.ts
+++ b/scripts/deploy.ts
@@ -73,18 +73,20 @@ async function checkRequiredEnvVars(): Promise<void> {
       name: 'NEXT_PUBLIC_MINI_APP_NAME',
       message: 'Enter the name for your frame (e.g., My Cool Mini App):',
       default: APP_NAME,
-      validate: (input: string) => input.trim() !== '' || 'Mini app name cannot be empty'
+      validate: (input: string) =>
+        input.trim() !== '' || 'Mini app name cannot be empty',
     },
     {
       name: 'NEXT_PUBLIC_MINI_APP_BUTTON_TEXT',
       message: 'Enter the text for your frame button:',
       default: APP_BUTTON_TEXT ?? 'Launch Mini App',
-      validate: (input: string) => input.trim() !== '' || 'Button text cannot be empty'
-    }
+      validate: (input: string) =>
+        input.trim() !== '' || 'Button text cannot be empty',
+    },
   ];
 
   const missingVars = requiredVars.filter(
-    (varConfig) => !process.env[varConfig.name]
+    varConfig => !process.env[varConfig.name],
   );
 
   if (missingVars.length > 0) {
@@ -110,7 +112,7 @@ async function checkRequiredEnvVars(): Promise<void> {
         const newLine = envContent ? '\n' : '';
         fs.appendFileSync(
           '.env',
-          `${newLine}${varConfig.name}="${value.trim()}"`
+          `${newLine}${varConfig.name}="${value.trim()}"`,
         );
       }
 
@@ -130,10 +132,10 @@ async function checkRequiredEnvVars(): Promise<void> {
 
         process.env.SPONSOR_SIGNER = sponsorSigner.toString();
 
-        if (storeSeedPhrase) {
+        if (process.env.SEED_PHRASE) {
           fs.appendFileSync(
             '.env.local',
-            `\nSPONSOR_SIGNER="${sponsorSigner}"`
+            `\nSPONSOR_SIGNER="${sponsorSigner}"`,
           );
           console.log('✅ Sponsor signer preference stored in .env.local');
         }
@@ -171,8 +173,8 @@ async function getGitRemote(): Promise<string | null> {
 
 async function checkVercelCLI(): Promise<boolean> {
   try {
-    execSync('vercel --version', { 
-      stdio: 'ignore'
+    execSync('vercel --version', {
+      stdio: 'ignore',
     });
     return true;
   } catch (error: unknown) {
@@ -185,8 +187,8 @@ async function checkVercelCLI(): Promise<boolean> {
 
 async function installVercelCLI(): Promise<void> {
   console.log('Installing Vercel CLI...');
-  execSync('npm install -g vercel', { 
-    stdio: 'inherit'
+  execSync('npm install -g vercel', {
+    stdio: 'inherit',
   });
 }
 
@@ -222,7 +224,9 @@ async function getVercelToken(): Promise<string | null> {
     return null; // We'll fall back to CLI operations
   } catch (error: unknown) {
     if (error instanceof Error) {
-      throw new Error('Not logged in to Vercel CLI. Please run this script again to login.');
+      throw new Error(
+        'Not logged in to Vercel CLI. Please run this script again to login.',
+      );
     }
     throw error;
   }
@@ -239,7 +243,7 @@ async function loginToVercel(): Promise<boolean> {
   console.log('3. Complete the Vercel account setup in your browser');
   console.log('4. Return here once your Vercel account is created\n');
   console.log(
-    '\nNote: you may need to cancel this script with ctrl+c and run it again if creating a new vercel account'
+    '\nNote: you may need to cancel this script with ctrl+c and run it again if creating a new vercel account',
   );
 
   const child = spawn('vercel', ['login'], {
@@ -247,14 +251,14 @@ async function loginToVercel(): Promise<boolean> {
   });
 
   await new Promise<void>((resolve, reject) => {
-    child.on('close', (code) => {
+    child.on('close', code => {
       resolve();
     });
   });
 
   console.log('\n📱 Waiting for login to complete...');
   console.log(
-    "If you're creating a new account, please complete the Vercel account setup in your browser first."
+    "If you're creating a new account, please complete the Vercel account setup in your browser first.",
   );
 
   for (let i = 0; i < 150; i++) {
@@ -263,10 +267,13 @@ async function loginToVercel(): Promise<boolean> {
       console.log('✅ Successfully logged in to Vercel!');
       return true;
     } catch (error: unknown) {
-      if (error instanceof Error && error.message.includes('Account not found')) {
+      if (
+        error instanceof Error &&
+        error.message.includes('Account not found')
+      ) {
         console.log('ℹ️  Waiting for Vercel account setup to complete...');
       }
-      await new Promise((resolve) => setTimeout(resolve, 2000));
+      await new Promise(resolve => setTimeout(resolve, 2000));
     }
   }
 
@@ -277,7 +284,12 @@ async function loginToVercel(): Promise<boolean> {
   return false;
 }
 
-async function setVercelEnvVarSDK(vercelClient: Vercel, projectId: string, key: string, value: string | object): Promise<boolean> {
+async function setVercelEnvVarSDK(
+  vercelClient: Vercel,
+  projectId: string,
+  key: string,
+  value: string | object,
+): Promise<boolean> {
   try {
     let processedValue: string;
     if (typeof value === 'object') {
@@ -287,17 +299,26 @@ async function setVercelEnvVarSDK(vercelClient: Vercel, projectId: string, key:
     }
 
     // Get existing environment variables
-    const existingVars = await vercelClient.projects.getEnvironmentVariables({
+    const existingVars = await vercelClient.projects.filterProjectEnvs({
       idOrName: projectId,
     });
 
-    const existingVar = existingVars.envs?.find((env: any) => 
-      env.key === key && env.target?.includes('production')
+    // Handle different response types
+    let envs: any[] = [];
+    if ('envs' in existingVars && Array.isArray(existingVars.envs)) {
+      envs = existingVars.envs;
+    } else if ('target' in existingVars && 'key' in existingVars) {
+      // Single environment variable response
+      envs = [existingVars];
+    }
+
+    const existingVar = envs.find(
+      (env: any) => env.key === key && env.target?.includes('production'),
     );
 
-    if (existingVar) {
+    if (existingVar && existingVar.id) {
       // Update existing variable
-      await vercelClient.projects.editEnvironmentVariable({
+      await vercelClient.projects.editProjectEnv({
         idOrName: projectId,
         id: existingVar.id,
         requestBody: {
@@ -308,7 +329,7 @@ async function setVercelEnvVarSDK(vercelClient: Vercel, projectId: string, key:
       console.log(`✅ Updated environment variable: ${key}`);
     } else {
       // Create new variable
-      await vercelClient.projects.createEnvironmentVariable({
+      await vercelClient.projects.createProjectEnv({
         idOrName: projectId,
         requestBody: {
           key: key,
@@ -323,14 +344,21 @@ async function setVercelEnvVarSDK(vercelClient: Vercel, projectId: string, key:
     return true;
   } catch (error: unknown) {
     if (error instanceof Error) {
-      console.warn(`⚠️  Warning: Failed to set environment variable ${key}:`, error.message);
+      console.warn(
+        `⚠️  Warning: Failed to set environment variable ${key}:`,
+        error.message,
+      );
       return false;
     }
     throw error;
   }
 }
 
-async function setVercelEnvVarCLI(key: string, value: string | object, projectRoot: string): Promise<boolean> {
+async function setVercelEnvVarCLI(
+  key: string,
+  value: string | object,
+  projectRoot: string,
+): Promise<boolean> {
   try {
     // Remove existing env var
     try {
@@ -365,7 +393,7 @@ async function setVercelEnvVarCLI(key: string, value: string | object, projectRo
     execSync(command, {
       cwd: projectRoot,
       stdio: 'pipe', // Changed from 'inherit' to avoid interactive prompts
-      env: process.env
+      env: process.env,
     });
 
     fs.unlinkSync(tempFilePath);
@@ -377,18 +405,26 @@ async function setVercelEnvVarCLI(key: string, value: string | object, projectRo
       fs.unlinkSync(tempFilePath);
     }
     if (error instanceof Error) {
-      console.warn(`⚠️  Warning: Failed to set environment variable ${key}:`, error.message);
+      console.warn(
+        `⚠️  Warning: Failed to set environment variable ${key}:`,
+        error.message,
+      );
       return false;
     }
     throw error;
   }
 }
 
-async function setEnvironmentVariables(vercelClient: Vercel | null, projectId: string | null, envVars: Record<string, string | object>, projectRoot: string): Promise<Array<{ key: string; success: boolean }>> {
+async function setEnvironmentVariables(
+  vercelClient: Vercel | null,
+  projectId: string | null,
+  envVars: Record<string, string | object>,
+  projectRoot: string,
+): Promise<Array<{ key: string; success: boolean }>> {
   console.log('\n📝 Setting up environment variables...');
-  
+
   const results: Array<{ key: string; success: boolean }> = [];
-  
+
   for (const [key, value] of Object.entries(envVars)) {
     if (!value) continue;
 
@@ -408,29 +444,34 @@ async function setEnvironmentVariables(vercelClient: Vercel | null, projectId: s
   }
 
   // Report results
-  const failed = results.filter((r) => !r.success);
+  const failed = results.filter(r => !r.success);
   if (failed.length > 0) {
     console.warn(`\n⚠️  Failed to set ${failed.length} environment variables:`);
-    failed.forEach((r) => console.warn(`   - ${r.key}`));
+    failed.forEach(r => console.warn(`   - ${r.key}`));
     console.warn(
-      '\nYou may need to set these manually in the Vercel dashboard.'
+      '\nYou may need to set these manually in the Vercel dashboard.',
     );
   }
 
   return results;
 }
 
-async function waitForDeployment(vercelClient: Vercel | null, projectId: string, maxWaitTime = 300000): Promise<any> { // 5 minutes
+async function waitForDeployment(
+  vercelClient: Vercel | null,
+  projectId: string,
+  maxWaitTime = 300000,
+): Promise<any> {
+  // 5 minutes
   console.log('\n⏳ Waiting for deployment to complete...');
   const startTime = Date.now();
 
   while (Date.now() - startTime < maxWaitTime) {
     try {
-      const deployments = await vercelClient?.deployments.list({
+      const deployments = await vercelClient?.deployments.getDeployments({
         projectId: projectId,
         limit: 1,
       });
-      
+
       if (deployments?.deployments?.[0]) {
         const deployment = deployments.deployments[0];
         console.log(`📊 Deployment status: ${deployment.state}`);
@@ -445,10 +486,10 @@ async function waitForDeployment(vercelClient: Vercel | null, projectId: string,
         }
 
         // Still building, wait and check again
-        await new Promise((resolve) => setTimeout(resolve, 5000)); // Wait 5 seconds
+        await new Promise(resolve => setTimeout(resolve, 5000)); // Wait 5 seconds
       } else {
         console.log('⏳ No deployment found yet, waiting...');
-        await new Promise((resolve) => setTimeout(resolve, 5000));
+        await new Promise(resolve => setTimeout(resolve, 5000));
       }
     } catch (error: unknown) {
       if (error instanceof Error) {
@@ -478,58 +519,60 @@ async function deployToVercel(useGitHub = false): Promise<void> {
             framework: 'nextjs',
           },
           null,
-          2
-        )
+          2,
+        ),
       );
     }
 
     // Set up Vercel project
     console.log('\n📦 Setting up Vercel project...');
     console.log(
-      'An initial deployment is required to get an assigned domain that can be used in the mini app manifest\n'
+      'An initial deployment is required to get an assigned domain that can be used in the mini app manifest\n',
     );
     console.log(
-      '\n⚠️ Note: choosing a longer, more unique project name will help avoid conflicts with other existing domains\n'
+      '\n⚠️ Note: choosing a longer, more unique project name will help avoid conflicts with other existing domains\n',
     );
 
     // Use spawn instead of execSync for better error handling
     const { spawn } = await import('child_process');
-    const vercelSetup = spawn('vercel', [], { 
-        cwd: projectRoot,
-        stdio: 'inherit',
-        shell: process.platform === 'win32' ? true : undefined
-      });
+    const vercelSetup = spawn('vercel', [], {
+      cwd: projectRoot,
+      stdio: 'inherit',
+      shell: process.platform === 'win32' ? true : undefined,
+    });
 
     await new Promise<void>((resolve, reject) => {
-      vercelSetup.on('close', (code) => {
+      vercelSetup.on('close', code => {
         if (code === 0 || code === null) {
           console.log('✅ Vercel project setup completed');
           resolve();
         } else {
-      console.log('⚠️  Vercel setup command completed (this is normal)');
+          console.log('⚠️  Vercel setup command completed (this is normal)');
           resolve(); // Don't reject, as this is often expected
         }
       });
 
-      vercelSetup.on('error', (error) => {
+      vercelSetup.on('error', error => {
         console.log('⚠️  Vercel setup command completed (this is normal)');
         resolve(); // Don't reject, as this is often expected
       });
     });
 
     // Wait a moment for project files to be written
-    await new Promise((resolve) => setTimeout(resolve, 2000));
+    await new Promise(resolve => setTimeout(resolve, 2000));
 
     // Load project info
     let projectId: string;
     try {
       const projectJson = JSON.parse(
-        fs.readFileSync('.vercel/project.json', 'utf8')
+        fs.readFileSync('.vercel/project.json', 'utf8'),
       );
       projectId = projectJson.projectId;
     } catch (error: unknown) {
       if (error instanceof Error) {
-        throw new Error('Failed to load project info. Please ensure the Vercel project was created successfully.');
+        throw new Error(
+          'Failed to load project info. Please ensure the Vercel project was created successfully.',
+        );
       }
       throw error;
     }
@@ -540,13 +583,15 @@ async function deployToVercel(useGitHub = false): Promise<void> {
       const token = await getVercelToken();
       if (token) {
         vercelClient = new Vercel({
-          bearerToken: token
+          bearerToken: token,
         });
         console.log('✅ Initialized Vercel SDK client');
       }
     } catch (error: unknown) {
       if (error instanceof Error) {
-        console.warn('⚠️  Could not initialize Vercel SDK, falling back to CLI operations');
+        console.warn(
+          '⚠️  Could not initialize Vercel SDK, falling back to CLI operations',
+        );
       }
       throw error;
     }
@@ -558,15 +603,22 @@ async function deployToVercel(useGitHub = false): Promise<void> {
 
     if (vercelClient) {
       try {
-        const project = await vercelClient.projects.get({
-          idOrName: projectId,
-        });
-        projectName = project.name;
-        domain = `${projectName}.vercel.app`;
-        console.log('🌐 Using project name for domain:', domain);
+        const projects = await vercelClient.projects.getProjects({});
+        const project = projects.projects.find(
+          (p: any) => p.id === projectId || p.name === projectId,
+        );
+        if (project) {
+          projectName = project.name;
+          domain = `${projectName}.vercel.app`;
+          console.log('🌐 Using project name for domain:', domain);
+        } else {
+          throw new Error('Project not found');
+        }
       } catch (error: unknown) {
         if (error instanceof Error) {
-          console.warn('⚠️  Could not get project details via SDK, using CLI fallback');
+          console.warn(
+            '⚠️  Could not get project details via SDK, using CLI fallback',
+          );
         }
         throw error;
       }
@@ -580,7 +632,7 @@ async function deployToVercel(useGitHub = false): Promise<void> {
           {
             cwd: projectRoot,
             encoding: 'utf8',
-          }
+          },
         );
 
         const nameMatch = inspectOutput.match(/Name\s+([^\n]+)/);
@@ -596,7 +648,7 @@ async function deployToVercel(useGitHub = false): Promise<void> {
             console.log('🌐 Using project name for domain:', domain);
           } else {
             console.warn(
-              '⚠️  Could not determine project name from inspection, using fallback'
+              '⚠️  Could not determine project name from inspection, using fallback',
             );
             // Use a fallback domain based on project ID
             domain = `project-${projectId.slice(-8)}.vercel.app`;
@@ -618,19 +670,29 @@ async function deployToVercel(useGitHub = false): Promise<void> {
     const nextAuthSecret =
       process.env.NEXTAUTH_SECRET || crypto.randomBytes(32).toString('hex');
     const vercelEnv = {
-      NEXTAUTH_SECRET: nextAuthSecret,
-      AUTH_SECRET: nextAuthSecret,
-      NEXTAUTH_URL: `https://${domain}`,
       NEXT_PUBLIC_URL: `https://${domain}`,
-      
-      ...(process.env.NEYNAR_API_KEY && { NEYNAR_API_KEY: process.env.NEYNAR_API_KEY }),
-      ...(process.env.NEYNAR_CLIENT_ID && { NEYNAR_CLIENT_ID: process.env.NEYNAR_CLIENT_ID }),
-      ...(process.env.SPONSOR_SIGNER && { SPONSOR_SIGNER: process.env.SPONSOR_SIGNER }),
-      
+
+      ...(process.env.NEYNAR_API_KEY && {
+        NEYNAR_API_KEY: process.env.NEYNAR_API_KEY,
+      }),
+      ...(process.env.NEYNAR_CLIENT_ID && {
+        NEYNAR_CLIENT_ID: process.env.NEYNAR_CLIENT_ID,
+      }),
+      ...(process.env.SPONSOR_SIGNER && {
+        SPONSOR_SIGNER: process.env.SPONSOR_SIGNER,
+      }),
+
+      // Include NextAuth environment variables if SEED_PHRASE is present or SPONSOR_SIGNER is true
+      ...((process.env.SEED_PHRASE || process.env.SPONSOR_SIGNER === 'true') && {
+        NEXTAUTH_SECRET: nextAuthSecret,
+        AUTH_SECRET: nextAuthSecret,
+        NEXTAUTH_URL: `https://${domain}`,
+      }),
+
       ...Object.fromEntries(
         Object.entries(process.env).filter(([key]) =>
-          key.startsWith('NEXT_PUBLIC_')
-        )
+          key.startsWith('NEXT_PUBLIC_'),
+        ),
       ),
     };
 
@@ -639,7 +701,7 @@ async function deployToVercel(useGitHub = false): Promise<void> {
       vercelClient,
       projectId,
       vercelEnv,
-      projectRoot
+      projectRoot,
     );
 
     // Deploy the project
@@ -663,7 +725,7 @@ async function deployToVercel(useGitHub = false): Promise<void> {
     });
 
     await new Promise<void>((resolve, reject) => {
-      vercelDeploy.on('close', (code) => {
+      vercelDeploy.on('close', code => {
         if (code === 0) {
           console.log('✅ Vercel deployment command completed');
           resolve();
@@ -673,7 +735,7 @@ async function deployToVercel(useGitHub = false): Promise<void> {
         }
       });
 
-      vercelDeploy.on('error', (error) => {
+      vercelDeploy.on('error', error => {
         console.error('❌ Vercel deployment error:', error.message);
         reject(error);
       });
@@ -686,7 +748,10 @@ async function deployToVercel(useGitHub = false): Promise<void> {
         deployment = await waitForDeployment(vercelClient, projectId);
       } catch (error: unknown) {
         if (error instanceof Error) {
-          console.warn('⚠️  Could not verify deployment completion:', error.message);
+          console.warn(
+            '⚠️  Could not verify deployment completion:',
+            error.message,
+          );
           console.log('ℹ️  Proceeding with domain verification...');
         }
         throw error;
@@ -700,10 +765,12 @@ async function deployToVercel(useGitHub = false): Promise<void> {
     if (vercelClient && deployment) {
       try {
         actualDomain = deployment.url || domain;
-          console.log('🌐 Verified actual domain:', actualDomain);
+        console.log('🌐 Verified actual domain:', actualDomain);
       } catch (error: unknown) {
         if (error instanceof Error) {
-          console.warn('⚠️  Could not verify domain via SDK, using assumed domain');
+          console.warn(
+            '⚠️  Could not verify domain via SDK, using assumed domain',
+          );
         }
         throw error;
       }
@@ -714,11 +781,20 @@ async function deployToVercel(useGitHub = false): Promise<void> {
       console.log('🔄 Updating environment variables with correct domain...');
 
       const updatedEnv: Record<string, string | object> = {
-        NEXTAUTH_URL: `https://${actualDomain}`,
         NEXT_PUBLIC_URL: `https://${actualDomain}`,
       };
 
-      await setEnvironmentVariables(vercelClient, projectId, updatedEnv, projectRoot);
+      // Include NextAuth URL if SEED_PHRASE is present or SPONSOR_SIGNER is true
+      if (process.env.SEED_PHRASE || process.env.SPONSOR_SIGNER === 'true') {
+        updatedEnv.NEXTAUTH_URL = `https://${actualDomain}`;
+      }
+
+      await setEnvironmentVariables(
+        vercelClient,
+        projectId,
+        updatedEnv,
+        projectRoot,
+      );
 
       console.log('\n📦 Redeploying with correct domain...');
       const vercelRedeploy = spawn('vercel', ['deploy', '--prod'], {
@@ -728,7 +804,7 @@ async function deployToVercel(useGitHub = false): Promise<void> {
       });
 
       await new Promise<void>((resolve, reject) => {
-        vercelRedeploy.on('close', (code) => {
+        vercelRedeploy.on('close', code => {
           if (code === 0) {
             console.log('✅ Redeployment completed');
             resolve();
@@ -738,7 +814,7 @@ async function deployToVercel(useGitHub = false): Promise<void> {
           }
         });
 
-        vercelRedeploy.on('error', (error) => {
+        vercelRedeploy.on('error', error => {
           console.error('❌ Redeployment error:', error.message);
           reject(error);
         });
@@ -749,13 +825,24 @@ async function deployToVercel(useGitHub = false): Promise<void> {
 
     console.log('\n✨ Deployment complete! Your mini app is now live at:');
     console.log(`🌐 https://${domain}`);
-    console.log('\n📝 You can manage your project at https://vercel.com/dashboard');
+    console.log(
+      '\n📝 You can manage your project at https://vercel.com/dashboard',
+    );
 
     // Prompt user to sign manifest in browser and paste accountAssociation
-    console.log(`\n⚠️  To complete your mini app manifest, you must sign it using the Farcaster developer portal.`);
-    console.log('1. Go to: https://farcaster.xyz/~/developers/mini-apps/manifest?domain=' + domain);
-    console.log('2. Click "Transfer Ownership" and follow the instructions to sign the manifest.');
-    console.log('3. Copy the resulting accountAssociation JSON from the browser.');
+    console.log(
+      `\n⚠️  To complete your mini app manifest, you must sign it using the Farcaster developer portal.`,
+    );
+    console.log(
+      '1. Go to: https://farcaster.xyz/~/developers/mini-apps/manifest?domain=' +
+        domain,
+    );
+    console.log(
+      '2. Click "Transfer Ownership" and follow the instructions to sign the manifest.',
+    );
+    console.log(
+      '3. Copy the resulting accountAssociation JSON from the browser.',
+    );
     console.log('4. Paste it below when prompted.');
 
     const { userAccountAssociation } = await inquirer.prompt([
@@ -773,8 +860,8 @@ async function deployToVercel(useGitHub = false): Promise<void> {
           } catch (e) {
             return 'Invalid JSON';
           }
-        }
-      }
+        },
+      },
     ]);
     const parsedAccountAssociation = JSON.parse(userAccountAssociation);
 
@@ -786,11 +873,10 @@ async function deployToVercel(useGitHub = false): Promise<void> {
     const newAccountAssociation = `export const APP_ACCOUNT_ASSOCIATION: AccountAssociation | undefined = ${JSON.stringify(parsedAccountAssociation, null, 2)};`;
     constantsContent = constantsContent.replace(
       /^export const APP_ACCOUNT_ASSOCIATION\s*:\s*AccountAssociation \| undefined\s*=\s*[^;]*;/m,
-      newAccountAssociation
+      newAccountAssociation,
     );
     fs.writeFileSync(constantsPath, constantsContent);
     console.log('\n✅ APP_ACCOUNT_ASSOCIATION updated in src/lib/constants.ts');
-
   } catch (error: unknown) {
     if (error instanceof Error) {
       console.error('\n❌ Deployment failed:', error.message);
@@ -804,7 +890,7 @@ async function main(): Promise<void> {
   try {
     console.log('🚀 Vercel Mini App Deployment (SDK Edition)');
     console.log(
-      'This script will deploy your mini app to Vercel using the Vercel SDK.'
+      'This script will deploy your mini app to Vercel using the Vercel SDK.',
     );
     console.log('\nThe script will:');
     console.log('1. Check for required environment variables');
@@ -818,9 +904,9 @@ async function main(): Promise<void> {
     } catch (error: unknown) {
       if (error instanceof Error) {
         console.log('📦 Installing @vercel/sdk...');
-        execSync('npm install @vercel/sdk', { 
+        execSync('npm install @vercel/sdk', {
           cwd: projectRoot,
-          stdio: 'inherit'
+          stdio: 'inherit',
         });
         console.log('✅ @vercel/sdk installed successfully');
       }
@@ -880,7 +966,6 @@ async function main(): Promise<void> {
     }
 
     await deployToVercel(useGitHub);
-
   } catch (error: unknown) {
     if (error instanceof Error) {
       console.error('\n❌ Error:', error.message);
diff --git a/src/app/api/auth/validate/route.ts b/src/app/api/auth/validate/route.ts
new file mode 100644
index 0000000..5a67b10
--- /dev/null
+++ b/src/app/api/auth/validate/route.ts
@@ -0,0 +1,46 @@
+import { NextResponse } from 'next/server';
+import { createClient, Errors } from '@farcaster/quick-auth';
+
+const client = createClient();
+
+export async function POST(request: Request) {
+  try {
+    const { token } = await request.json();
+
+    if (!token) {
+      return NextResponse.json({ error: 'Token is required' }, { status: 400 });
+    }
+
+    // Get domain from environment or request
+    const domain = process.env.NEXT_PUBLIC_URL
+      ? new URL(process.env.NEXT_PUBLIC_URL).hostname
+      : request.headers.get('host') || 'localhost';
+
+    try {
+      // Use the official QuickAuth library to verify the JWT
+      const payload = await client.verifyJwt({
+        token,
+        domain,
+      });
+
+      return NextResponse.json({
+        success: true,
+        user: {
+          fid: payload.sub,
+        },
+      });
+    } catch (e) {
+      if (e instanceof Errors.InvalidTokenError) {
+        console.info('Invalid token:', e.message);
+        return NextResponse.json({ error: 'Invalid token' }, { status: 401 });
+      }
+      throw e;
+    }
+  } catch (error) {
+    console.error('Token validation error:', error);
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 },
+    );
+  }
+}
\ No newline at end of file
diff --git a/src/app/layout.tsx b/src/app/layout.tsx
index b7a8dde..f009466 100644
--- a/src/app/layout.tsx
+++ b/src/app/layout.tsx
@@ -1,6 +1,5 @@
 import type { Metadata } from "next";
 
-import { getSession } from "~/auth"
 import "~/app/globals.css";
 import { Providers } from "~/app/providers";
 import { APP_NAME, APP_DESCRIPTION } from "~/lib/constants";
@@ -15,7 +14,19 @@ export default async function RootLayout({
 }: Readonly<{
   children: React.ReactNode;
 }>) {  
-  const session = await getSession()
+  // Only get session if sponsored signer is enabled or seed phrase is provided
+  const sponsorSigner = process.env.SPONSOR_SIGNER === 'true';
+  const hasSeedPhrase = !!process.env.SEED_PHRASE;
+  
+  let session = null;
+  if (sponsorSigner || hasSeedPhrase) {
+    try {
+      const { getSession } = await import("~/auth");
+      session = await getSession();
+    } catch (error) {
+      console.warn('Failed to get session:', error);
+    }
+  }
 
   return (
     <html lang="en">
diff --git a/src/app/providers.tsx b/src/app/providers.tsx
index 90584eb..09a96b3 100644
--- a/src/app/providers.tsx
+++ b/src/app/providers.tsx
@@ -24,18 +24,36 @@ export function Providers({
 }) {
   const solanaEndpoint =
     process.env.SOLANA_RPC_ENDPOINT || 'https://solana-rpc.publicnode.com';
+  
+  // Only wrap with SessionProvider if session is provided
+  if (session) {
+    return (
+      <SessionProvider session={session}>
+        <WagmiProvider>
+          <MiniAppProvider
+            analyticsEnabled={ANALYTICS_ENABLED}
+            backButtonEnabled={true}
+          >
+            <SafeFarcasterSolanaProvider endpoint={solanaEndpoint}>
+              <AuthKitProvider config={{}}>{children}</AuthKitProvider>
+            </SafeFarcasterSolanaProvider>
+          </MiniAppProvider>
+        </WagmiProvider>
+      </SessionProvider>
+    );
+  }
+  
+  // Return without SessionProvider if no session
   return (
-    <SessionProvider session={session}>
-      <WagmiProvider>
-        <MiniAppProvider
-          analyticsEnabled={ANALYTICS_ENABLED}
-          backButtonEnabled={true}
-        >
-          <SafeFarcasterSolanaProvider endpoint={solanaEndpoint}>
-            <AuthKitProvider config={{}}>{children}</AuthKitProvider>
-          </SafeFarcasterSolanaProvider>
-        </MiniAppProvider>
-      </WagmiProvider>
-    </SessionProvider>
+    <WagmiProvider>
+      <MiniAppProvider
+        analyticsEnabled={ANALYTICS_ENABLED}
+        backButtonEnabled={true}
+      >
+        <SafeFarcasterSolanaProvider endpoint={solanaEndpoint}>
+          <AuthKitProvider config={{}}>{children}</AuthKitProvider>
+        </SafeFarcasterSolanaProvider>
+      </MiniAppProvider>
+    </WagmiProvider>
   );
 }
diff --git a/src/components/ui/tabs/ActionsTab.tsx b/src/components/ui/tabs/ActionsTab.tsx
index cc072d1..18e6e22 100644
--- a/src/components/ui/tabs/ActionsTab.tsx
+++ b/src/components/ui/tabs/ActionsTab.tsx
@@ -1,13 +1,23 @@
 'use client';
 
-import { useCallback, useState } from 'react';
+import { useCallback, useState, type ComponentType } from 'react';
 import { useMiniApp } from '@neynar/react';
 import { ShareButton } from '../Share';
 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';
+
+// Optional import for NeynarAuthButton - may not exist in all templates
+let NeynarAuthButton: ComponentType | null = null;
+try {
+  const module = require('../NeynarAuthButton/index');
+  NeynarAuthButton = module.NeynarAuthButton;
+} catch (error) {
+  // Component doesn't exist, that's okay
+  console.log('NeynarAuthButton not available in this template');
+}
+
 
 /**
  * ActionsTab component handles mini app actions like sharing, notifications, and haptic feedback.
@@ -140,7 +150,7 @@ export function ActionsTab() {
       <SignIn />
 
       {/* Neynar Authentication */}
-      <NeynarAuthButton />
+      {NeynarAuthButton && <NeynarAuthButton />}
 
       {/* Mini app actions */}
       <Button
diff --git a/src/components/ui/wallet/SignIn.tsx b/src/components/ui/wallet/SignIn.tsx
index 9ca825c..c6b5adf 100644
--- a/src/components/ui/wallet/SignIn.tsx
+++ b/src/components/ui/wallet/SignIn.tsx
@@ -1,22 +1,20 @@
 'use client';
 
-import { useCallback, useState } from "react";
-import { signIn, signOut, getCsrfToken } from "next-auth/react";
-import sdk, { SignIn as SignInCore } from "@farcaster/miniapp-sdk";
-import { useSession } from "next-auth/react";
-import { Button } from "../Button";
+import { useCallback, useState } from 'react';
+import { SignIn as SignInCore } from '@farcaster/miniapp-sdk';
+import { useQuickAuth } from '~/hooks/useQuickAuth';
+import { Button } from '../Button';
 
 /**
- * SignIn component handles Farcaster authentication using Sign-In with Farcaster (SIWF).
+ * SignIn component handles Farcaster authentication using QuickAuth.
  *
  * 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
+ * - Uses the built-in QuickAuth functionality from the Farcaster SDK
+ * - Manages authentication state in memory (no persistence)
  * - Provides sign-out functionality
  * - Displays authentication status and results
  *
- * The component integrates with both the Farcaster Frame SDK and NextAuth
+ * The component integrates with the Farcaster Frame SDK and QuickAuth
  * to provide seamless authentication within mini apps.
  *
  * @example
@@ -36,52 +34,32 @@ export function SignIn() {
     signingIn: false,
     signingOut: false,
   });
-  const [signInResult, setSignInResult] = useState<SignInCore.SignInResult>();
   const [signInFailure, setSignInFailure] = useState<string>();
 
   // --- Hooks ---
-  const { data: session, status } = useSession();
+  const { authenticatedUser, status, signIn, signOut } = useQuickAuth();
 
   // --- Handlers ---
   /**
-   * Generates a nonce for the sign-in process.
+   * Handles the sign-in process using QuickAuth.
    *
-   * 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');
-    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
+   * This function uses the built-in QuickAuth functionality:
+   * 1. Gets a token from QuickAuth (handles SIWF flow automatically)
+   * 2. Validates the token with our server
+   * 3. Updates the session state
    *
    * @returns Promise<void>
    */
   const handleSignIn = useCallback(async () => {
     try {
-      setAuthState((prev) => ({ ...prev, signingIn: true }));
+      setAuthState(prev => ({ ...prev, signingIn: true }));
       setSignInFailure(undefined);
-      const nonce = await getNonce();
-      const result = await sdk.actions.signIn({ nonce });
-      setSignInResult(result);
-      await signIn('farcaster', {
-        message: result.message,
-        signature: result.signature,
-        redirect: false,
-      });
+
+      const success = await signIn();
+
+      if (!success) {
+        setSignInFailure('Authentication failed');
+      }
     } catch (e) {
       if (e instanceof SignInCore.RejectedByUser) {
         setSignInFailure('Rejected by user');
@@ -89,52 +67,49 @@ export function SignIn() {
       }
       setSignInFailure('Unknown error');
     } finally {
-      setAuthState((prev) => ({ ...prev, signingIn: false }));
+      setAuthState(prev => ({ ...prev, signingIn: false }));
     }
-  }, [getNonce]);
+  }, [signIn]);
 
   /**
    * Handles the sign-out process.
    *
-   * This function clears the NextAuth session only if the current session
-   * is using the Farcaster provider, and resets the local sign-in result state.
+   * This function clears the QuickAuth session and resets the local state.
    *
    * @returns Promise<void>
    */
   const handleSignOut = useCallback(async () => {
     try {
-      setAuthState((prev) => ({ ...prev, signingOut: true }));
-      // Only sign out if the current session is from Farcaster provider
-      if (session?.provider === 'farcaster') {
-        await signOut({ redirect: false });
-      }
-      setSignInResult(undefined);
+      setAuthState(prev => ({ ...prev, signingOut: true }));
+      await signOut();
     } finally {
-      setAuthState((prev) => ({ ...prev, signingOut: false }));
+      setAuthState(prev => ({ ...prev, signingOut: false }));
     }
-  }, [session]);
+  }, [signOut]);
 
   // --- Render ---
   return (
     <>
       {/* Authentication Buttons */}
-      {(status !== 'authenticated' || session?.provider !== 'farcaster') && (
+      {status !== 'authenticated' && (
         <Button onClick={handleSignIn} disabled={authState.signingIn}>
           Sign In with Farcaster
         </Button>
       )}
-      {status === 'authenticated' && session?.provider === 'farcaster' && (
+      {status === 'authenticated' && (
         <Button onClick={handleSignOut} disabled={authState.signingOut}>
           Sign out
         </Button>
       )}
 
       {/* Session Information */}
-      {session && (
+      {authenticatedUser && (
         <div className="my-2 p-2 text-xs overflow-x-scroll bg-gray-100 dark:bg-gray-900 rounded-lg font-mono">
-          <div className="font-semibold text-gray-500 dark:text-gray-300 mb-1">Session</div>
+          <div className="font-semibold text-gray-500 dark:text-gray-300 mb-1">
+            Authenticated User
+          </div>
           <div className="whitespace-pre text-gray-700 dark:text-gray-200">
-            {JSON.stringify(session, null, 2)}
+            {JSON.stringify(authenticatedUser, null, 2)}
           </div>
         </div>
       )}
@@ -142,20 +117,14 @@ export function SignIn() {
       {/* Error Display */}
       {signInFailure && !authState.signingIn && (
         <div className="my-2 p-2 text-xs overflow-x-scroll bg-gray-100 dark:bg-gray-900 rounded-lg font-mono">
-          <div className="font-semibold text-gray-500 dark:text-gray-300 mb-1">SIWF Result</div>
-          <div className="whitespace-pre text-gray-700 dark:text-gray-200">{signInFailure}</div>
-        </div>
-      )}
-
-      {/* Success Result Display */}
-      {signInResult && !authState.signingIn && (
-        <div className="my-2 p-2 text-xs overflow-x-scroll bg-gray-100 dark:bg-gray-900 rounded-lg font-mono">
-          <div className="font-semibold text-gray-500 dark:text-gray-300 mb-1">SIWF Result</div>
+          <div className="font-semibold text-gray-500 dark:text-gray-300 mb-1">
+            Authentication Error
+          </div>
           <div className="whitespace-pre text-gray-700 dark:text-gray-200">
-            {JSON.stringify(signInResult, null, 2)}
+            {signInFailure}
           </div>
         </div>
       )}
     </>
   );
-}
+}
\ No newline at end of file
diff --git a/src/hooks/useQuickAuth.ts b/src/hooks/useQuickAuth.ts
new file mode 100644
index 0000000..bd982ff
--- /dev/null
+++ b/src/hooks/useQuickAuth.ts
@@ -0,0 +1,207 @@
+'use client';
+
+import { useState, useEffect, useCallback } from 'react';
+import { sdk } from '@farcaster/miniapp-sdk';
+
+/**
+ * Represents the current authenticated user state
+ */
+interface AuthenticatedUser {
+  /** The user's Farcaster ID (FID) */
+  fid: number;
+}
+
+/**
+ * Possible authentication states for QuickAuth
+ */
+type QuickAuthStatus = 'loading' | 'authenticated' | 'unauthenticated';
+
+/**
+ * Return type for the useQuickAuth hook
+ */
+interface UseQuickAuthReturn {
+  /** Current authenticated user data, or null if not authenticated */
+  authenticatedUser: AuthenticatedUser | null;
+  /** Current authentication status */
+  status: QuickAuthStatus;
+  /** Function to initiate the sign-in process using QuickAuth */
+  signIn: () => Promise<boolean>;
+  /** Function to sign out and clear the current authentication state */
+  signOut: () => Promise<void>;
+  /** Function to retrieve the current authentication token */
+  getToken: () => Promise<string | null>;
+}
+
+/**
+ * Custom hook for managing QuickAuth authentication state
+ *
+ * This hook provides a complete authentication flow using Farcaster's QuickAuth:
+ * - Automatically checks for existing authentication on mount
+ * - Validates tokens with the server-side API
+ * - Manages authentication state in memory (no persistence)
+ * - Provides sign-in/sign-out functionality
+ *
+ * QuickAuth tokens are managed in memory only, so signing out of the Farcaster
+ * client will automatically sign the user out of this mini app as well.
+ *
+ * @returns {UseQuickAuthReturn} Object containing user state and authentication methods
+ *
+ * @example
+ * ```tsx
+ * const { authenticatedUser, status, signIn, signOut } = useQuickAuth();
+ *
+ * if (status === 'loading') return <div>Loading...</div>;
+ * if (status === 'unauthenticated') return <button onClick={signIn}>Sign In</button>;
+ *
+ * return (
+ *   <div>
+ *     <p>Welcome, FID: {authenticatedUser?.fid}</p>
+ *     <button onClick={signOut}>Sign Out</button>
+ *   </div>
+ * );
+ * ```
+ */
+export function useQuickAuth(): UseQuickAuthReturn {
+  // Current authenticated user data
+  const [authenticatedUser, setAuthenticatedUser] =
+    useState<AuthenticatedUser | null>(null);
+  // Current authentication status
+  const [status, setStatus] = useState<QuickAuthStatus>('loading');
+
+  /**
+   * Validates a QuickAuth token with the server-side API
+   *
+   * @param {string} authToken - The JWT token to validate
+   * @returns {Promise<AuthenticatedUser | null>} User data if valid, null otherwise
+   */
+  const validateTokenWithServer = async (
+    authToken: string,
+  ): Promise<AuthenticatedUser | null> => {
+    try {
+      const validationResponse = await fetch('/api/auth/validate', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ token: authToken }),
+      });
+
+      if (validationResponse.ok) {
+        const responseData = await validationResponse.json();
+        return responseData.user;
+      }
+
+      return null;
+    } catch (error) {
+      console.error('Token validation failed:', error);
+      return null;
+    }
+  };
+
+  /**
+   * Checks for existing authentication token and validates it on component mount
+   * This runs automatically when the hook is first used
+   */
+  useEffect(() => {
+    const checkExistingAuthentication = async () => {
+      try {
+        // Attempt to retrieve existing token from QuickAuth SDK
+        const { token } = await sdk.quickAuth.getToken();
+
+        if (token) {
+          // Validate the token with our server-side API
+          const validatedUserSession = await validateTokenWithServer(token);
+
+          if (validatedUserSession) {
+            // Token is valid, set authenticated state
+            setAuthenticatedUser(validatedUserSession);
+            setStatus('authenticated');
+          } else {
+            // Token is invalid or expired, clear authentication state
+            setStatus('unauthenticated');
+          }
+        } else {
+          // No existing token found, user is not authenticated
+          setStatus('unauthenticated');
+        }
+      } catch (error) {
+        console.error('Error checking existing authentication:', error);
+        setStatus('unauthenticated');
+      }
+    };
+
+    checkExistingAuthentication();
+  }, []);
+
+  /**
+   * Initiates the QuickAuth sign-in process
+   *
+   * Uses sdk.quickAuth.getToken() to get a QuickAuth session token.
+   * If there is already a session token in memory that hasn't expired,
+   * it will be immediately returned, otherwise a fresh one will be acquired.
+   *
+   * @returns {Promise<boolean>} True if sign-in was successful, false otherwise
+   */
+  const signIn = useCallback(async (): Promise<boolean> => {
+    try {
+      setStatus('loading');
+
+      // Get QuickAuth session token
+      const { token } = await sdk.quickAuth.getToken();
+
+      if (token) {
+        // Validate the token with our server-side API
+        const validatedUserSession = await validateTokenWithServer(token);
+
+        if (validatedUserSession) {
+          // Authentication successful, update user state
+          setAuthenticatedUser(validatedUserSession);
+          setStatus('authenticated');
+          return true;
+        }
+      }
+
+      // Authentication failed, clear user state
+      setStatus('unauthenticated');
+      return false;
+    } catch (error) {
+      console.error('Sign-in process failed:', error);
+      setStatus('unauthenticated');
+      return false;
+    }
+  }, []);
+
+  /**
+   * Signs out the current user and clears the authentication state
+   *
+   * Since QuickAuth tokens are managed in memory only, this simply clears
+   * the local user state. The actual token will be cleared when the
+   * user signs out of their Farcaster client.
+   */
+  const signOut = useCallback(async (): Promise<void> => {
+    // Clear local user state
+    setAuthenticatedUser(null);
+    setStatus('unauthenticated');
+  }, []);
+
+  /**
+   * Retrieves the current authentication token from QuickAuth
+   *
+   * @returns {Promise<string | null>} The current auth token, or null if not authenticated
+   */
+  const getToken = useCallback(async (): Promise<string | null> => {
+    try {
+      const { token } = await sdk.quickAuth.getToken();
+      return token;
+    } catch (error) {
+      console.error('Failed to retrieve authentication token:', error);
+      return null;
+    }
+  }, []);
+
+  return {
+    authenticatedUser,
+    status,
+    signIn,
+    signOut,
+    getToken,
+  };
+}
\ No newline at end of file