fix: update sponsored signer question

Formatting

.editorconfig

@@ -0,0 +1,29 @@
+# EditorConfig is awesome: https://EditorConfig.org
+
+# top-most EditorConfig file
+root = true
+
+# Unix-style newlines with a newline ending every file
+[*]
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+charset = utf-8
+
+# Matches multiple files with brace expansion notation
+[*.{js,jsx,ts,tsx,json,css,scss,md,mdx,yml,yaml}]
+indent_style = space
+indent_size = 2
+
+# Tab indentation (no size specified)
+[Makefile]
+indent_style = tab
+
+# Matches the exact files
+[{package.json,.travis.yml}]
+indent_style = space
+indent_size = 2
+
+# Markdown files
+[*.md]
+trim_trailing_whitespace = false

.env.example

@@ -4,3 +4,8 @@ KV_REST_API_TOKEN=''
 KV_REST_API_URL=''
 NEXT_PUBLIC_URL='http://localhost:3000'
 NEXTAUTH_URL='http://localhost:3000'
+
+NEXTAUTH_SECRET=""
+NEYNAR_API_KEY=""
+NEYNAR_CLIENT_ID=""
+USE_TUNNEL="false"

.eslintignore

@@ -0,0 +1,95 @@
+# Dependencies
+node_modules/
+.pnp/
+.pnp.*
+
+# Build outputs
+.next/
+out/
+build/
+dist/
+
+# Environment files
+.env*
+!.env.example
+
+# Generated files
+next-env.d.ts
+*.tsbuildinfo
+
+# Package manager lock files
+package-lock.json
+yarn.lock
+pnpm-lock.yaml
+
+# Vercel
+.vercel/
+
+# Logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Editor files
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Git
+.git/
+
+# Temporary files
+tmp/
+temp/
+
+# Coverage
+coverage/
+.nyc_output
+
+# Cache directories
+.cache/
+.parcel-cache/
+.eslintcache
+
+# Storybook build outputs
+storybook-static
+
+# Database
+*.db
+*.sqlite
+
+# Documentation
+docs/
+
+# Auto-generated files
+*.d.ts
+!src/**/*.d.ts
+!types/**/*.d.ts
+
+# Test coverage
+*.lcov
+
+# Compiled binary addons
+build/Release
+
+# Yarn
+.yarn/cache
+.yarn/unplugged
+.yarn/build-state.yml
+.yarn/install-state.gz
+
+# Scripts that should be ignored by eslint
+scripts/deploy.ts

.eslintrc.json

@@ -1,3 +1,113 @@
 {
-  "extends": ["next/core-web-vitals", "next/typescript"]
+  "root": true,
+  "env": {
+    "browser": true,
+    "es2022": true,
+    "node": true
+  },
+  "extends": [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/recommended",
+    "next/core-web-vitals",
+    "next/typescript"
+  ],
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": {
+    "ecmaVersion": "latest",
+    "sourceType": "module",
+    "ecmaFeatures": {
+      "jsx": true
+    },
+    "project": "./tsconfig.json"
+  },
+  "plugins": ["@typescript-eslint"],
+  "rules": {
+    "@typescript-eslint/no-unused-vars": [
+      "error",
+      {
+        "argsIgnorePattern": "^_",
+        "varsIgnorePattern": "^_",
+        "caughtErrorsIgnorePattern": "^_"
+      }
+    ],
+    "@typescript-eslint/explicit-function-return-type": "off",
+    "@typescript-eslint/explicit-module-boundary-types": "off",
+    "@typescript-eslint/no-explicit-any": "warn",
+    "prefer-const": "error",
+    "@typescript-eslint/no-floating-promises": "warn",
+    "@typescript-eslint/await-thenable": "error",
+    "@typescript-eslint/no-misused-promises": "warn",
+    "@typescript-eslint/require-await": "warn",
+    "react/display-name": "off",
+    "react/prop-types": "off",
+    "react/jsx-uses-react": "off",
+    "react/react-in-jsx-scope": "off",
+    "no-console": ["warn", { "allow": ["warn", "error"] }],
+    "no-var": "error",
+    "no-multiple-empty-lines": ["error", { "max": 1, "maxEOF": 0 }],
+    "no-trailing-spaces": "error",
+    "eol-last": "error",
+    "semi": ["error", "always"],
+    "quotes": ["error", "single", { "avoidEscape": true }],
+    "import/order": [
+      "error",
+      {
+        "groups": [
+          "builtin",
+          "external",
+          "internal",
+          "parent",
+          "sibling",
+          "index"
+        ],
+        "pathGroups": [
+          {
+            "pattern": "react",
+            "group": "external",
+            "position": "before"
+          },
+          {
+            "pattern": "next/**",
+            "group": "external",
+            "position": "before"
+          },
+          {
+            "pattern": "~/**",
+            "group": "internal"
+          }
+        ],
+        "pathGroupsExcludedImportTypes": ["react"],
+        "newlines-between": "never",
+        "alphabetize": {
+          "order": "asc",
+          "caseInsensitive": true
+        }
+      }
+    ]
+  },
+  "overrides": [
+    {
+      "files": ["*.js", "*.jsx"],
+      "parserOptions": {
+        "project": null
+      },
+      "rules": {
+        "@typescript-eslint/no-var-requires": "off",
+        "@typescript-eslint/no-require-imports": "off",
+        "@typescript-eslint/no-floating-promises": "off",
+        "@typescript-eslint/await-thenable": "off",
+        "@typescript-eslint/no-misused-promises": "off",
+        "@typescript-eslint/require-await": "off",
+        "@typescript-eslint/no-unused-vars": "off",
+        "no-console": "off"
+      }
+    },
+    {
+      "files": ["*.config.js", "*.config.ts", "next.config.*"],
+      "rules": {
+        "@typescript-eslint/no-var-requires": "off",
+        "@typescript-eslint/no-require-imports": "off"
+      }
+    }
+  ]
 }

.github/workflows/publish.yml

@@ -0,0 +1,30 @@
+name: Publish to npm 🚀
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - package.json
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v4
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          registry-url: 'https://registry.npmjs.org'
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Publish to npm
+        run: npm publish --access public

.gitignore

@@ -39,3 +39,25 @@ yarn-error.log*
 # typescript
 *.tsbuildinfo
 next-env.d.ts
+
+# IDE and editor files
+.vscode/settings.json
+.idea/
+*.swp
+*.swo
+*~
+
+# Linting and formatting cache
+.eslintcache
+.prettierignore.bak
+
+# OS generated files
+Thumbs.db
+
+# Package manager files
+.pnpm-debug.log*
+.yarn-integrity
+
+# Temporary files
+tmp/
+temp/

.lintstagedrc

@@ -0,0 +1,4 @@
+{
+  "*.{js,jsx,ts,tsx}": ["eslint --fix", "prettier --write"],
+  "*.{json,css,scss,md,mdx,yml,yaml}": ["prettier --write"]
+}

.prettierignore

@@ -0,0 +1,204 @@
+# Dependencies
+node_modules/
+.pnp/
+.pnp.*
+
+# Build outputs
+.next/
+out/
+build/
+dist/
+
+# Environment files
+.env*
+!.env.example
+
+# Logs
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+lerna-debug.log*
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Coverage directory used by tools like istanbul
+coverage/
+*.lcov
+
+# nyc test coverage
+.nyc_output
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Snowpack dependency directory
+web_modules/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Microbundle cache
+.rpt2_cache/
+.rts2_cache_cjs/
+.rts2_cache_es/
+.rts2_cache_umd/
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# parcel-bundler cache
+.cache
+.parcel-cache
+
+# Stores VSCode versions used for testing VSCode extensions
+.vscode-test
+
+# yarn v2
+.yarn/cache
+.yarn/unplugged
+.yarn/build-state.yml
+.yarn/install-state.gz
+.pnp.*
+
+# Generated files
+next-env.d.ts
+
+# Package manager lock files
+package-lock.json
+yarn.lock
+pnpm-lock.yaml
+
+# Vercel
+.vercel/
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Temporary files
+tmp/
+temp/
+
+# Database
+*.db
+*.sqlite
+
+# Compiled binary addons
+build/Release
+
+# Documentation
+docs/
+
+# Git
+.git/
+.gitignore
+
+# Editor files
+*.swp
+*.swo
+*~
+
+# Changelog
+CHANGELOG.md
+
+# Auto-generated documentation
+api-docs/
+
+# Dependency directories
+node_modules/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Microbundle cache
+.rpt2_cache/
+.rts2_cache_cjs/
+.rts2_cache_es/
+.rts2_cache_umd/
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+.parcel-cache
+
+# Next.js build output
+.next
+
+# Nuxt.js build / generate output
+.nuxt
+dist
+
+# Storybook build outputs
+.out
+.storybook-out
+
+# Temporary folders
+tmp/
+temp/
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Vercel
+.vercel
+
+# Package manager lock files
+package-lock.json
+yarn.lock
+pnpm-lock.yaml
+
+# Git
+.git/

.prettierrc

@@ -0,0 +1,17 @@
+{
+  "semi": true,
+  "trailingComma": "all",
+  "singleQuote": true,
+  "printWidth": 80,
+  "tabWidth": 2,
+  "useTabs": false,
+  "bracketSpacing": true,
+  "bracketSameLine": false,
+  "arrowParens": "avoid",
+  "endOfLine": "lf",
+  "quoteProps": "as-needed",
+  "proseWrap": "preserve",
+  "htmlWhitespaceSensitivity": "css",
+  "embeddedLanguageFormatting": "auto",
+  "singleAttributePerLine": false
+}

.vscode/extensions.json

@@ -0,0 +1,13 @@
+{
+  "recommendations": [
+    "esbenp.prettier-vscode",
+    "dbaeumer.vscode-eslint",
+    "bradlc.vscode-tailwindcss",
+    "ms-vscode.vscode-typescript-next",
+    "editorconfig.editorconfig",
+    "christian-kohler.path-intellisense",
+    "ms-vscode.vscode-json",
+    "formulahendry.auto-rename-tag",
+    "christian-kohler.npm-intellisense"
+  ]
+}

README.md

@@ -1,4 +1,4 @@
-# Farcaster Mini Apps (formerly Frames) Quickstart by Neynar 🪐
+# Farcaster Mini Apps (formerly Frames v2) Quickstart by Neynar 🪐
 
 A Farcaster Mini Apps quickstart npx script.
 
@@ -11,24 +11,51 @@ Check out [this Neynar docs page](https://docs.neynar.com/docs/create-farcaster-
 ## Getting Started
 
 To create a new mini app project, run:
+
 ```{bash}
 npx @neynar/create-farcaster-mini-app@latest
 ```
 
 To run the project:
+
 ```{bash}
 cd <PROJECT_NAME>
 npm run dev
 ```
 
+## Code Formatting & Linting
+
+This template includes comprehensive formatting and linting tools to ensure consistent code quality:
+
+- **Prettier**: Automatic code formatting
+- **ESLint**: Code linting with Next.js and TypeScript support
+- **EditorConfig**: Cross-editor consistency
+
+### Available Scripts
+
+```bash
+npm run format        # Format all files with Prettier
+npm run format:check  # Check if files are properly formatted
+npm run lint          # Run ESLint
+npm run lint:fix      # Fix ESLint issues automatically
+npm run type-check    # Run TypeScript type checking
+npm run check         # Run all checks (types, lint, format)
+```
+
+See [FORMATTING.md](./FORMATTING.md) for detailed configuration and setup information.
+
 ### Importing the CLI
+
 To invoke the CLI directly in JavaScript, add the npm package to your project and use the following import statement:
+
 ```{javascript}
 import { init } from '@neynar/create-farcaster-mini-app';
 ```
 
 ## Deploying to Vercel
+
 For projects that have made minimal changes to the quickstart template, deploy to vercel by running:
+
 ```{bash}
 npm run deploy:vercel
 ```
@@ -36,6 +63,7 @@ npm run deploy:vercel
 ## Building for Production
 
 To create a production build, run:
+
 ```{bash}
 npm run build
 ```
@@ -51,11 +79,12 @@ This section is only for working on the script and template. If you simply want
 To iterate on the CLI and test changes in a generated app without publishing to npm:
 
 1. In your installer/template repo (this repo), run:
+
    ```bash
    npm link
    ```
-   This makes your local version globally available as a symlinked package.
 
+   This makes your local version globally available as a symlinked package.
 
 1. Now, when you run:
    ```bash
@@ -76,4 +105,3 @@ However, this does not fully replicate the npx install flow and may not catch al
 ### Environment Variables and Scripts
 
 If you update environment variable handling, remember to replicate any changes in the `dev`, `build`, and `deploy` scripts as needed. The `build` and `deploy` scripts may need further updates and are less critical for most development workflows.
-

bin/index.js

@@ -2,7 +2,61 @@
 
 import { init } from './init.js';
 
-init().catch((err) => {
+// Parse command line arguments
+const args = process.argv.slice(2);
+let projectName = null;
+let autoAcceptDefaults = false;
+let apiKey = null;
+
+// Check for -y flag
+const yIndex = args.indexOf('-y');
+if (yIndex !== -1) {
+  autoAcceptDefaults = true;
+  args.splice(yIndex, 1); // Remove -y from args
+}
+
+// Parse other arguments
+for (let i = 0; i < args.length; i++) {
+  const arg = args[i];
+
+  if (arg === '-p' || arg === '--project') {
+    if (i + 1 < args.length) {
+      projectName = args[i + 1];
+      if (projectName.startsWith('-')) {
+        console.error('Error: Project name cannot start with a dash (-)');
+        process.exit(1);
+      }
+      args.splice(i, 2); // Remove both the flag and its value
+      i--; // Adjust index since we removed 2 elements
+    } else {
+      console.error('Error: -p/--project requires a project name');
+      process.exit(1);
+    }
+  } else if (arg === '-k' || arg === '--api-key') {
+    if (i + 1 < args.length) {
+      apiKey = args[i + 1];
+      if (apiKey.startsWith('-')) {
+        console.error('Error: API key cannot start with a dash (-)');
+        process.exit(1);
+      }
+      args.splice(i, 2); // Remove both the flag and its value
+      i--; // Adjust index since we removed 2 elements
+    } else {
+      console.error('Error: -k/--api-key requires an API key');
+      process.exit(1);
+    }
+  }
+}
+
+// Validate that if -y is used, a project name must be provided
+if (autoAcceptDefaults && !projectName) {
+  console.error(
+    'Error: -y flag requires a project name. Use -p/--project to specify the project name.',
+  );
+  process.exit(1);
+}
+
+init(projectName, autoAcceptDefaults, apiKey).catch(err => {
   console.error('Error:', err);
   process.exit(1);
 });

bin/init.js

@@ -1,18 +1,20 @@
 #!/usr/bin/env node
 
-import inquirer from 'inquirer';
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
 import { execSync } from 'child_process';
-import fs from 'fs';
-import path from 'path';
 import crypto from 'crypto';
+import fs from 'fs';
+import { dirname } from 'path';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import inquirer from 'inquirer';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
 const REPO_URL = 'https://github.com/neynarxyz/create-farcaster-mini-app.git';
-const SCRIPT_VERSION = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8')).version;
+const SCRIPT_VERSION = JSON.parse(
+  fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8'),
+).version;
 
 // ANSI color codes
 const purple = '\x1b[35m';
@@ -27,7 +29,7 @@ function printWelcomeMessage() {
   console.log(`
 ${purple}╔═══════════════════════════════════════════════════╗${reset}
 ${purple}║                                                   ║${reset}
-${purple}║${reset}     ${bright}Welcome to Mini Apps Quickstart by Neynar${reset}     ${purple}║${reset}
+${purple}║${reset}         ${bright}Welcome to the Neynar Starter Kit${reset}         ${purple}║${reset}
 ${purple}║${reset}   ${dim}the quickest way to build Farcaster mini apps${reset}   ${purple}║${reset}
 ${purple}║                                                   ║${reset}
 ${purple}╚═══════════════════════════════════════════════════╝${reset}
@@ -45,12 +47,12 @@ async function queryNeynarApp(apiKey) {
   }
   try {
     const response = await fetch(
-      `https://api.neynar.com/portal/app_by_api_key?starter_kit=true`,
+      'https://api.neynar.com/portal/app_by_api_key?starter_kit=true',
       {
         headers: {
-          'x-api-key': apiKey
-        }
-      }
+          'x-api-key': apiKey,
+        },
+      },
     );
     const data = await response.json();
     return data;
@@ -61,7 +63,11 @@ async function queryNeynarApp(apiKey) {
 }
 
 // Export the main CLI function for programmatic use
-export async function init() {
+export async function init(
+  projectName = null,
+  autoAcceptDefaults = false,
+  apiKey = null,
+) {
   printWelcomeMessage();
 
   // Ask about Neynar usage
@@ -72,65 +78,104 @@ export async function init() {
   let neynarAppLogoUrl = null;
 
   while (useNeynar) {
-    const neynarAnswers = await inquirer.prompt([
-      {
-        type: 'confirm',
-        name: 'useNeynar',
-        message: `🪐 ${purple}${bright}${italic}Neynar is an API that makes it easy to build on Farcaster.${reset}\n\n` +
-        'Benefits of using Neynar in your mini app:\n' +
-        '- Pre-configured webhook handling (no setup required)\n' +
-        '- Automatic mini app analytics in your dev portal\n' +
-        '- Send manual notifications from dev.neynar.com\n' +
-        '- Built-in rate limiting and error handling\n\n' +
-        `${purple}${bright}${italic}A demo API key is included if you would like to try out Neynar before signing up!${reset}\n\n` +
-        'Would you like to use Neynar in your mini app?',
-        default: true
-      }
-    ]);
+    let neynarAnswers;
+    if (autoAcceptDefaults) {
+      neynarAnswers = { useNeynar: true };
+    } else {
+      neynarAnswers = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'useNeynar',
+          message:
+            `🪐 ${purple}${bright}${italic}Neynar is an API that makes it easy to build on Farcaster.${reset}\n\n` +
+            'Benefits of using Neynar in your mini app:\n' +
+            '- Pre-configured webhook handling (no setup required)\n' +
+            '- Automatic mini app analytics in your dev portal\n' +
+            '- Send manual notifications from dev.neynar.com\n' +
+            '- Built-in rate limiting and error handling\n\n' +
+            `${purple}${bright}${italic}A demo API key is included if you would like to try out Neynar before signing up!${reset}\n\n` +
+            'Would you like to use Neynar in your mini app?',
+          default: true,
+        },
+      ]);
+    }
 
     if (!neynarAnswers.useNeynar) {
       useNeynar = false;
       break;
     }
 
-    const neynarKeyAnswer = await inquirer.prompt([
-      {
-        type: 'password',
-        name: 'neynarApiKey',
-        message: 'Enter your Neynar API key (or press enter to skip):',
-        default: null
-      }
-    ]);
-
-    if (neynarKeyAnswer.neynarApiKey) {
-      neynarApiKey = neynarKeyAnswer.neynarApiKey;
+    // Use provided API key if available, otherwise prompt for it
+    if (apiKey) {
+      neynarApiKey = apiKey;
     } else {
-      const useDemoKey = await inquirer.prompt([
-        {
-          type: 'confirm',
-          name: 'useDemo',
-          message: 'Would you like to try the demo Neynar API key?',
-          default: true
-        }
-      ]);
+      if (!autoAcceptDefaults) {
+        console.log(
+          '\n🪐 Find your Neynar API key at: https://dev.neynar.com/app\n',
+        );
+      }
 
-      if (useDemoKey.useDemo) {
-        console.warn('\n⚠️ Note: the demo key is for development purposes only and is aggressively rate limited.');
-        console.log('For production, please sign up for a Neynar account at https://neynar.com/ and configure the API key in your .env or .env.local file with NEYNAR_API_KEY.');
-        console.log(`\n${purple}${bright}${italic}Neynar now has a free tier! See https://neynar.com/#pricing for details.\n${reset}`);
-        neynarApiKey = 'FARCASTER_V2_FRAMES_DEMO';
+      let neynarKeyAnswer;
+      if (autoAcceptDefaults) {
+        neynarKeyAnswer = { neynarApiKey: null };
+      } else {
+        neynarKeyAnswer = await inquirer.prompt([
+          {
+            type: 'password',
+            name: 'neynarApiKey',
+            message: 'Enter your Neynar API key (or press enter to skip):',
+            default: null,
+          },
+        ]);
+      }
+
+      if (neynarKeyAnswer.neynarApiKey) {
+        neynarApiKey = neynarKeyAnswer.neynarApiKey;
+      } else {
+        let useDemoKey;
+        if (autoAcceptDefaults) {
+          useDemoKey = { useDemo: true };
+        } else {
+          useDemoKey = await inquirer.prompt([
+            {
+              type: 'confirm',
+              name: 'useDemo',
+              message: 'Would you like to try the demo Neynar API key?',
+              default: true,
+            },
+          ]);
+        }
+
+        if (useDemoKey.useDemo) {
+          console.warn(
+            '\n⚠️ Note: the demo key is for development purposes only and is aggressively rate limited.',
+          );
+          console.log(
+            'For production, please sign up for a Neynar account at https://neynar.com/ and configure the API key in your .env or .env.local file with NEYNAR_API_KEY.',
+          );
+          console.log(
+            `\n${purple}${bright}${italic}Neynar now has a free tier! See https://neynar.com/#pricing for details.\n${reset}`,
+          );
+          neynarApiKey = 'FARCASTER_V2_FRAMES_DEMO';
+        }
       }
     }
 
     if (!neynarApiKey) {
-      console.log('\n⚠️  No valid API key provided. Would you like to try again?');
+      if (autoAcceptDefaults) {
+        useNeynar = false;
+        break;
+      }
+      console.log(
+        '\n⚠️  No valid API key provided. Would you like to try again?',
+      );
       const { retry } = await inquirer.prompt([
         {
           type: 'confirm',
           name: 'retry',
           message: 'Try configuring Neynar again?',
-          default: true
-        }
+          default: true,
+        },
       ]);
       if (!retry) {
         useNeynar = false;
@@ -147,13 +192,18 @@ export async function init() {
     }
 
     if (!neynarClientId) {
+      if (autoAcceptDefaults) {
+        useNeynar = false;
+        break;
+      }
       const { retry } = await inquirer.prompt([
         {
           type: 'confirm',
           name: 'retry',
-          message: '⚠️  Could not find a client ID for this API key. Would you like to try configuring Neynar again?',
-          default: true
-        }
+          message:
+            '⚠️  Could not find a client ID for this API key. Would you like to try configuring Neynar again?',
+          default: true,
+        },
       ]);
       if (!retry) {
         useNeynar = false;
@@ -166,123 +216,184 @@ export async function init() {
     break;
   }
 
-  const defaultFrameName = (neynarAppName && !neynarAppName.toLowerCase().includes('demo')) ? neynarAppName : undefined;
+  const defaultMiniAppName =
+    neynarAppName && !neynarAppName.toLowerCase().includes('demo')
+      ? neynarAppName
+      : undefined;
 
-  const answers = await inquirer.prompt([
-    {
-      type: 'input',
-      name: 'projectName',
-      message: 'What is the name of your mini app?',
-      default: defaultFrameName,
-      validate: (input) => {
-        if (input.trim() === '') {
-          return 'Project name cannot be empty';
-        }
-        return true;
-      }
-    },
-    {
-      type: 'input',
-      name: 'description',
-      message: 'Give a one-line description of your mini app (optional):',
-      default: 'A Farcaster mini app created with Neynar'
-    },
-    {
-      type: 'list',
-      name: 'primaryCategory',
-      message: 'It is strongly recommended to choose a primary category and tags to help users discover your mini app.\n\nSelect a primary category:',
-      choices: [
-        new inquirer.Separator(),
-        { name: 'Skip (not recommended)', value: null },
-        new inquirer.Separator(),
-        { name: 'Games', value: 'games' },
-        { name: 'Social', value: 'social' },
-        { name: 'Finance', value: 'finance' },
-        { name: 'Utility', value: 'utility' },
-        { name: 'Productivity', value: 'productivity' },
-        { name: 'Health & Fitness', value: 'health-fitness' },
-        { name: 'News & Media', value: 'news-media' },
-        { name: 'Music', value: 'music' },
-        { name: 'Shopping', value: 'shopping' },
-        { name: 'Education', value: 'education' },
-        { name: 'Developer Tools', value: 'developer-tools' },
-        { name: 'Entertainment', value: 'entertainment' },
-        { name: 'Art & Creativity', value: 'art-creativity' }
-      ],
-      default: null
-    },
-    {
-      type: 'input',
-      name: 'tags',
-      message: 'Enter tags for your mini app (separate with spaces or commas, optional):',
-      default: '',
-      filter: (input) => {
-        if (!input.trim()) return [];
-        // Split by both spaces and commas, trim whitespace, and filter out empty strings
-        return input
-          .split(/[,\s]+/)
-          .map(tag => tag.trim())
-          .filter(tag => tag.length > 0);
-      }
-    },
-    {
-      type: 'input',
-      name: 'buttonText',
-      message: 'Enter the button text for your mini app:',
-      default: 'Launch Mini App',
-      validate: (input) => {
-        if (input.trim() === '') {
-          return 'Button text cannot be empty';
-        }
-        return true;
-      }
+  let answers;
+  if (autoAcceptDefaults) {
+    answers = {
+      projectName: projectName || defaultMiniAppName || 'my-farcaster-mini-app',
+      description: 'A Farcaster mini app created with Neynar',
+      primaryCategory: null,
+      tags: [],
+      buttonText: 'Launch Mini App',
+      useWallet: true,
+      useTunnel: true,
+      enableAnalytics: true,
+      seedPhrase: null,
+      sponsorSigner: false,
+    };
+  } else {
+    // If autoAcceptDefaults is false but we have a projectName, we still need to ask for other options
+    const projectNamePrompt = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'projectName',
+        message: 'What is the name of your mini app?',
+        default: projectName || defaultMiniAppName,
+        validate: input => {
+          if (input.trim() === '') {
+            return 'Project name cannot be empty';
+          }
+          return true;
+        },
+      },
+    ]);
+
+    answers = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'description',
+        message: 'Give a one-line description of your mini app (optional):',
+        default: 'A Farcaster mini app created with Neynar',
+      },
+      {
+        type: 'list',
+        name: 'primaryCategory',
+        message:
+          'It is strongly recommended to choose a primary category and tags to help users discover your mini app.\n\nSelect a primary category:',
+        choices: [
+          new inquirer.Separator(),
+          { name: 'Skip (not recommended)', value: null },
+          new inquirer.Separator(),
+          { name: 'Games', value: 'games' },
+          { name: 'Social', value: 'social' },
+          { name: 'Finance', value: 'finance' },
+          { name: 'Utility', value: 'utility' },
+          { name: 'Productivity', value: 'productivity' },
+          { name: 'Health & Fitness', value: 'health-fitness' },
+          { name: 'News & Media', value: 'news-media' },
+          { name: 'Music', value: 'music' },
+          { name: 'Shopping', value: 'shopping' },
+          { name: 'Education', value: 'education' },
+          { name: 'Developer Tools', value: 'developer-tools' },
+          { name: 'Entertainment', value: 'entertainment' },
+          { name: 'Art & Creativity', value: 'art-creativity' },
+        ],
+        default: null,
+      },
+      {
+        type: 'input',
+        name: 'tags',
+        message:
+          'Enter tags for your mini app (separate with spaces or commas, optional):',
+        default: '',
+        filter: input => {
+          if (!input.trim()) return [];
+          // Split by both spaces and commas, trim whitespace, and filter out empty strings
+          return input
+            .split(/[,\s]+/)
+            .map(tag => tag.trim())
+            .filter(tag => tag.length > 0);
+        },
+      },
+      {
+        type: 'input',
+        name: 'buttonText',
+        message: 'Enter the button text for your mini app:',
+        default: 'Launch Mini App',
+        validate: input => {
+          if (input.trim() === '') {
+            return 'Button text cannot be empty';
+          }
+          return true;
+        },
+      },
+    ]);
+
+    // Merge project name from the first prompt
+    answers.projectName = projectNamePrompt.projectName;
+
+    // Ask about wallet and transaction tooling
+    const walletAnswer = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'useWallet',
+        message:
+          'Would you like to include wallet and transaction tooling in your mini app?\n' +
+          'This includes:\n' +
+          '- EVM wallet connection\n' +
+          '- Transaction signing\n' +
+          '- Message signing\n' +
+          '- Chain switching\n' +
+          '- Solana support\n\n' +
+          'Include wallet and transaction features?',
+        default: true,
+      },
+    ]);
+    answers.useWallet = walletAnswer.useWallet;
+
+    // Ask about localhost vs tunnel
+    const hostingAnswer = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'useTunnel',
+        message:
+          'Would you like to test on mobile and/or test the app with Warpcast developer tools?\n' +
+          `⚠️ ${yellow}${italic}Both mobile testing and the Warpcast debugger require setting up a tunnel to serve your app from localhost to the broader internet.\n${reset}` +
+          'Configure a tunnel for mobile testing and/or Warpcast developer tools?',
+        default: true,
+      },
+    ]);
+    answers.useTunnel = hostingAnswer.useTunnel;
+
+    // Ask about Neynar Sponsored Signers / SIWN
+    const sponsoredSignerAnswer = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'useSponsoredSigner',
+        message: 'Do you want to write data to Farcaster?\n\nThis feature uses Neynar Sponsored Signers to sign messages on behalf of users.' + 
+          '\n⚠️ A seed phrase is required for this option.\n',
+        default: false,
+      },
+    ]);
+    answers.useSponsoredSigner = sponsoredSignerAnswer.useSponsoredSigner;
+
+    if (answers.useSponsoredSigner) {
+      const { seedPhrase } = await inquirer.prompt([
+        {
+          type: 'password',
+          name: 'seedPhrase',
+          message:
+            'Enter your Farcaster custody account seed phrase (required for Neynar Sponsored Signers/SIWN):',
+          validate: input => {
+            if (!input || input.trim().split(' ').length < 12) {
+              return 'Seed phrase must be at least 12 words';
+            }
+            return true;
+          },
+        },
+      ]);
+      answers.seedPhrase = seedPhrase;
     }
-  ]);
 
-  // Ask about wallet and transaction tooling
-  const walletAnswer = await inquirer.prompt([
-    {
-      type: 'confirm',
-      name: 'useWallet',
-      message: 'Would you like to include wallet and transaction tooling in your mini app?\n' +
-        'This includes:\n' +
-        '- EVM wallet connection\n' +
-        '- Transaction signing\n' +
-        '- Message signing\n' +
-        '- Chain switching\n' +
-        '- Solana support\n\n' +
-        'Include wallet and transaction features?',
-      default: true
-    }
-  ]);
-  answers.useWallet = walletAnswer.useWallet;
+    // Ask about analytics opt-out
+    const analyticsAnswer = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'enableAnalytics',
+        message:
+          'Would you like to help improve Neynar products by sharing usage data from your mini app?',
+        default: true,
+      },
+    ]);
+    answers.enableAnalytics = analyticsAnswer.enableAnalytics;
+  }
 
-  // Ask about localhost vs tunnel
-  const hostingAnswer = await inquirer.prompt([
-    {
-      type: 'confirm',
-      name: 'useTunnel',
-      message: 'Would you like to test on mobile and/or test the app with Warpcast developer tools?\n' +
-        `⚠️ ${yellow}${italic}Both mobile testing and the Warpcast debugger require setting up a tunnel to serve your app from localhost to the broader internet.\n${reset}` +
-        'Configure a tunnel for mobile testing and/or Warpcast developer tools?',
-      default: true
-    }
-  ]);
-  answers.useTunnel = hostingAnswer.useTunnel;
-
-  // Ask about analytics opt-out
-  const analyticsAnswer = await inquirer.prompt([
-    {
-      type: 'confirm',
-      name: 'enableAnalytics',
-      message: 'Would you like to help improve Neynar products by sharing usage data from your mini app?',
-      default: true
-    }
-  ]);
-  answers.enableAnalytics = analyticsAnswer.enableAnalytics;
-
-  const projectName = answers.projectName;
-  const projectDirName = projectName.replace(/\s+/g, '-').toLowerCase();
+  const finalProjectName = answers.projectName;
+  const projectDirName = finalProjectName.replace(/\s+/g, '-').toLowerCase();
   const projectPath = path.join(process.cwd(), projectDirName);
 
   console.log(`\nCreating a new mini app in ${projectPath}`);
@@ -293,17 +404,17 @@ export async function init() {
     // Use separate commands for better cross-platform compatibility
     execSync(`git clone ${REPO_URL} "${projectPath}"`, {
       stdio: 'inherit',
-      shell: process.platform === 'win32'
+      shell: process.platform === 'win32',
     });
     execSync('git fetch origin main', {
       cwd: projectPath,
       stdio: 'inherit',
-      shell: process.platform === 'win32'
+      shell: process.platform === 'win32',
     });
     execSync('git reset --hard origin/main', {
       cwd: projectPath,
       stdio: 'inherit',
-      shell: process.platform === 'win32'
+      shell: process.platform === 'win32',
     });
   } catch (error) {
     console.error('\n❌ Error: Failed to create project directory.');
@@ -325,9 +436,9 @@ export async function init() {
   // Update package.json
   console.log('\nUpdating package.json...');
   const packageJsonPath = path.join(projectPath, 'package.json');
-  let packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
 
-  packageJson.name = projectName;
+  packageJson.name = finalProjectName;
   packageJson.version = '0.1.0';
   delete packageJson.author;
   delete packageJson.keywords;
@@ -340,46 +451,54 @@ export async function init() {
 
   // Add dependencies
   packageJson.dependencies = {
-    "@farcaster/auth-client": ">=0.3.0 <1.0.0",
-    "@farcaster/auth-kit": ">=0.6.0 <1.0.0",
-    "@farcaster/frame-core": ">=0.0.29 <1.0.0",
-    "@farcaster/frame-node": ">=0.0.18 <1.0.0",
-    "@farcaster/frame-sdk": ">=0.0.31 <1.0.0",
-    "@farcaster/frame-wagmi-connector": ">=0.0.19 <1.0.0",
-    "@farcaster/mini-app-solana": ">=0.0.17 <1.0.0",
-    "@neynar/react": "^1.2.2",
-    "@radix-ui/react-label": "^2.1.1",
-    "@solana/wallet-adapter-react": "^0.15.38",
-    "@tanstack/react-query": "^5.61.0",
-    "@upstash/redis": "^1.34.3",
-    "class-variance-authority": "^0.7.1",
-    "clsx": "^2.1.1",
-    "dotenv": "^16.4.7",
-    "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",
-    "tailwindcss-animate": "^1.0.7",
-    "viem": "^2.23.6",
-    "wagmi": "^2.14.12",
-    "zod": "^3.24.2"
+    '@farcaster/auth-client': '>=0.3.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',
+    '@tanstack/react-query': '^5.61.0',
+    '@upstash/redis': '^1.34.3',
+    'class-variance-authority': '^0.7.1',
+    clsx: '^2.1.1',
+    dotenv: '^16.4.7',
+    'lucide-react': '^0.469.0',
+    mipd: '^0.0.7',
+    next: '^15',
+    react: '^19',
+    'react-dom': '^19',
+    'tailwind-merge': '^2.6.0',
+    'tailwindcss-animate': '^1.0.7',
+    viem: '^2.23.6',
+    wagmi: '^2.14.12',
+    zod: '^3.24.2',
+    siwe: '^3.0.0',
   };
 
+  // Add auth-kit and quick-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';
+  }
+
   packageJson.devDependencies = {
-    "@types/node": "^20",
-    "@types/react": "^19",
-    "@types/react-dom": "^19",
-    "crypto": "^1.0.1",
-    "eslint": "^8",
-    "eslint-config-next": "15.0.3",
-    "localtunnel": "^2.0.2",
-    "pino-pretty": "^13.0.0",
-    "postcss": "^8",
-    "tailwindcss": "^3.4.1",
-    "typescript": "^5"
+    '@types/inquirer': '^9.0.8',
+    '@types/node': '^20',
+    '@types/react': '^19',
+    '@types/react-dom': '^19',
+    '@vercel/sdk': '^1.9.0',
+    crypto: '^1.0.1',
+    eslint: '^8',
+    'eslint-config-next': '15.0.3',
+    localtunnel: '^2.0.2',
+    'pino-pretty': '^13.0.0',
+    postcss: '^8',
+    tailwindcss: '^3.4.1',
+    'ts-node': '^10.9.2',
+    typescript: '^5',
   };
 
   // Add Neynar SDK if selected
@@ -399,28 +518,147 @@ export async function init() {
     // Write it to .env.local
     fs.writeFileSync(envPath, envExampleContent);
 
-    // Append all remaining environment variables
-    fs.appendFileSync(envPath, `\nNEXT_PUBLIC_FRAME_NAME="${answers.projectName}"`);
-    fs.appendFileSync(envPath, `\nNEXT_PUBLIC_FRAME_DESCRIPTION="${answers.description}"`);
-    fs.appendFileSync(envPath, `\nNEXT_PUBLIC_FRAME_PRIMARY_CATEGORY="${answers.primaryCategory}"`);
-    fs.appendFileSync(envPath, `\nNEXT_PUBLIC_FRAME_TAGS="${answers.tags.join(',')}"`);
-    fs.appendFileSync(envPath, `\nNEXT_PUBLIC_FRAME_BUTTON_TEXT="${answers.buttonText}"`);
-    fs.appendFileSync(envPath, `\nNEXT_PUBLIC_ANALYTICS_ENABLED="${answers.enableAnalytics}"`);
-    fs.appendFileSync(envPath, `\nNEXT_PUBLIC_USE_WALLET="${answers.useWallet}"`);
+    // Append remaining environment variables
+    // Update constants.ts file with user-provided values
+    console.log('\nUpdating constants.ts...');
+    const constantsPath = path.join(projectPath, 'src', 'lib', 'constants.ts');
+    if (fs.existsSync(constantsPath)) {
+      let constantsContent = fs.readFileSync(constantsPath, 'utf8');
 
-    fs.appendFileSync(envPath, `\nNEXTAUTH_SECRET="${crypto.randomBytes(32).toString('hex')}"`);
+      // Helper function to escape single quotes in strings
+      const escapeString = str => str.replace(/'/g, "\\'");
+
+      // Helper function to safely replace constants with validation
+      const safeReplace = (content, pattern, replacement, constantName) => {
+        const match = content.match(pattern);
+        if (!match) {
+          console.log(
+            `⚠️  Warning: Could not update ${constantName} in constants.ts. Pattern not found.`,
+          );
+          console.log(`Pattern: ${pattern}`);
+          console.log(
+            `Expected to match in: ${
+              content.split('\n').find(line => line.includes(constantName)) ||
+              'Not found'
+            }`,
+          );
+        } else {
+          const newContent = content.replace(pattern, replacement);
+          return newContent;
+        }
+        return content;
+      };
+
+      // Regex patterns that match whole lines with export const (with TypeScript types)
+      const patterns = {
+        APP_NAME:
+          /^export const APP_NAME\s*:\s*string\s*=\s*['"`][^'"`]*['"`];$/m,
+        APP_DESCRIPTION:
+          /^export const APP_DESCRIPTION\s*:\s*string\s*=\s*['"`][^'"`]*['"`];$/m,
+        APP_PRIMARY_CATEGORY:
+          /^export const APP_PRIMARY_CATEGORY\s*:\s*string\s*=\s*['"`][^'"`]*['"`];$/m,
+        APP_TAGS: /^export const APP_TAGS\s*:\s*string\[\]\s*=\s*\[[^\]]*\];$/m,
+        APP_BUTTON_TEXT:
+          /^export const APP_BUTTON_TEXT\s*:\s*string\s*=\s*['"`][^'"`]*['"`];$/m,
+        USE_WALLET:
+          /^export const USE_WALLET\s*:\s*boolean\s*=\s*(true|false);$/m,
+        ANALYTICS_ENABLED:
+          /^export const ANALYTICS_ENABLED\s*:\s*boolean\s*=\s*(true|false);$/m,
+      };
+
+      // Update APP_NAME
+      constantsContent = safeReplace(
+        constantsContent,
+        patterns.APP_NAME,
+        `export const APP_NAME = '${escapeString(answers.projectName)}';`,
+        'APP_NAME',
+      );
+
+      // Update APP_DESCRIPTION
+      constantsContent = safeReplace(
+        constantsContent,
+        patterns.APP_DESCRIPTION,
+        `export const APP_DESCRIPTION = '${escapeString(
+          answers.description,
+        )}';`,
+        'APP_DESCRIPTION',
+      );
+
+      // Update APP_PRIMARY_CATEGORY (always update, null becomes empty string)
+      constantsContent = safeReplace(
+        constantsContent,
+        patterns.APP_PRIMARY_CATEGORY,
+        `export const APP_PRIMARY_CATEGORY = '${escapeString(
+          answers.primaryCategory || '',
+        )}';`,
+        'APP_PRIMARY_CATEGORY',
+      );
+
+      // Update APP_TAGS
+      const tagsString =
+        answers.tags.length > 0
+          ? `['${answers.tags.map(tag => escapeString(tag)).join("', '")}']`
+          : "['neynar', 'starter-kit', 'demo']";
+      constantsContent = safeReplace(
+        constantsContent,
+        patterns.APP_TAGS,
+        `export const APP_TAGS = ${tagsString};`,
+        'APP_TAGS',
+      );
+
+      // Update APP_BUTTON_TEXT (always update, use answers value)
+      constantsContent = safeReplace(
+        constantsContent,
+        patterns.APP_BUTTON_TEXT,
+        `export const APP_BUTTON_TEXT = '${escapeString(
+          answers.buttonText || '',
+        )}';`,
+        'APP_BUTTON_TEXT',
+      );
+
+      // Update USE_WALLET
+      constantsContent = safeReplace(
+        constantsContent,
+        patterns.USE_WALLET,
+        `export const USE_WALLET = ${answers.useWallet};`,
+        'USE_WALLET',
+      );
+
+      // Update ANALYTICS_ENABLED
+      constantsContent = safeReplace(
+        constantsContent,
+        patterns.ANALYTICS_ENABLED,
+        `export const ANALYTICS_ENABLED = ${answers.enableAnalytics};`,
+        'ANALYTICS_ENABLED',
+      );
+
+      fs.writeFileSync(constantsPath, constantsContent);
+    } else {
+      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}"`);
     } else if (useNeynar) {
-      console.log('\n⚠️  Could not find a Neynar client ID and/or API key. Please configure Neynar manually in .env.local with NEYNAR_API_KEY and NEYNAR_CLIENT_ID');
+      console.log(
+        '\n⚠️  Could not find a Neynar client ID and/or API key. Please configure Neynar manually in .env.local with NEYNAR_API_KEY and NEYNAR_CLIENT_ID',
+      );
+    }
+    if (answers.seedPhrase) {
+      fs.appendFileSync(envPath, `\nSEED_PHRASE="${answers.seedPhrase}"`);
     }
     fs.appendFileSync(envPath, `\nUSE_TUNNEL="${answers.useTunnel}"`);
 
     fs.unlinkSync(envExamplePath);
-    console.log('\nCreated .env.local file from .env.example');
   } else {
-    console.log('\n.env.example does not exist, skipping copy and remove operations');
+    console.log(
+      '\n.env.example does not exist, skipping copy and remove operations',
+    );
   }
 
   // Update README
@@ -428,7 +666,9 @@ export async function init() {
   const readmePath = path.join(projectPath, 'README.md');
   const prependText = `<!-- generated by @neynar/create-farcaster-mini-app version ${SCRIPT_VERSION} -->\n\n`;
   if (fs.existsSync(readmePath)) {
-    const originalReadmeContent = fs.readFileSync(readmePath, { encoding: 'utf8' });
+    const originalReadmeContent = fs.readFileSync(readmePath, {
+      encoding: 'utf8',
+    });
     const updatedReadmeContent = prependText + originalReadmeContent;
     fs.writeFileSync(readmePath, updatedReadmeContent);
   } else {
@@ -441,12 +681,12 @@ export async function init() {
   execSync('npm cache clean --force', {
     cwd: projectPath,
     stdio: 'inherit',
-    shell: process.platform === 'win32'
+    shell: process.platform === 'win32',
   });
   execSync('npm install', {
     cwd: projectPath,
     stdio: 'inherit',
-    shell: process.platform === 'win32'
+    shell: process.platform === 'win32',
   });
 
   // Remove the bin directory
@@ -456,21 +696,33 @@ export async function init() {
     fs.rmSync(binPath, { recursive: true, force: true });
   }
 
+  // Remove NeynarAuthButton directory if useSponsoredSigner is false
+  if (!answers.useSponsoredSigner) {
+    console.log('\nRemoving NeynarAuthButton directory (useSponsoredSigner is false)...');
+    const neynarAuthButtonPath = path.join(projectPath, 'src', 'components', 'ui', 'NeynarAuthButton');
+    if (fs.existsSync(neynarAuthButtonPath)) {
+      fs.rmSync(neynarAuthButtonPath, { recursive: true, force: true });
+    }
+  }
+
   // Initialize git repository
   console.log('\nInitializing git repository...');
   execSync('git init', { cwd: projectPath });
   execSync('git add .', { cwd: projectPath });
-  execSync('git commit -m "initial commit from @neynar/create-farcaster-mini-app"', { cwd: projectPath });
+  execSync(
+    'git commit -m "initial commit from @neynar/create-farcaster-mini-app"',
+    { cwd: projectPath },
+  );
 
   // Calculate border length based on message length
-  const message = `✨🪐 Successfully created frame ${projectName} with git and dependencies installed! 🪐✨`;
+  const message = `✨🪐 Successfully created mini app ${finalProjectName} with git and dependencies installed! 🪐✨`;
   const borderLength = message.length;
-  const borderStars = '✨'.repeat((borderLength / 2) + 1);
+  const borderStars = '✨'.repeat(borderLength / 2 + 1);
 
   console.log(`\n${borderStars}`);
   console.log(`${message}`);
   console.log(`${borderStars}`);
   console.log('\nTo run the app:');
-  console.log(`  cd ${projectName}`);
+  console.log(`  cd ${finalProjectName}`);
   console.log('  npm run dev\n');
 }

next.config.ts

@@ -1,4 +1,4 @@
-import type { NextConfig } from "next";
+import type { NextConfig } from 'next';
 
 const nextConfig: NextConfig = {
   /* config options here */

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neynar/create-farcaster-mini-app",
-  "version": "1.3.2",
+  "version": "1.7.3",
   "type": "module",
   "private": false,
   "access": "public",
@@ -31,11 +31,16 @@
   ],
   "scripts": {
     "dev": "node scripts/dev.js",
-    "build": "node scripts/build.js",
+    "build": "next build",
+    "build:raw": "next build",
     "start": "next start",
     "lint": "next lint",
-    "deploy:vercel": "node scripts/deploy.js",
-    "cleanup": "lsof -ti :3000 | xargs kill -9"
+    "lint:fix": "next lint --fix",
+    "format:check": "prettier --check .",
+    "format": "prettier --write . && eslint --fix . --max-warnings 50",
+    "deploy:vercel": "ts-node scripts/deploy.ts",
+    "deploy:raw": "vercel --prod",
+    "cleanup": "node scripts/cleanup.js"
   },
   "bin": {
     "@neynar/create-farcaster-mini-app": "./bin/index.js"
@@ -48,6 +53,11 @@
   "devDependencies": {
     "@neynar/nodejs-sdk": "^2.19.0",
     "@types/node": "^22.13.10",
+    "@typescript-eslint/eslint-plugin": "^8.35.1",
+    "@typescript-eslint/parser": "^8.35.1",
+    "eslint": "^8.57.0",
+    "eslint-config-next": "^15.0.0",
+    "prettier": "^3.3.3",
     "typescript": "^5.6.3"
   }
 }

scripts/build.js

@@ -1,417 +0,0 @@
-import { execSync } from 'child_process';
-import fs from 'fs';
-import path from 'path';
-import { mnemonicToAccount } from 'viem/accounts';
-import { fileURLToPath } from 'url';
-import inquirer from 'inquirer';
-import dotenv from 'dotenv';
-import crypto from 'crypto';
-
-// ANSI color codes
-const yellow = '\x1b[33m';
-const italic = '\x1b[3m';
-const reset = '\x1b[0m';
-
-// Load environment variables in specific order
-// First load .env for main config
-dotenv.config({ path: '.env' });
-
-async function lookupFidByCustodyAddress(custodyAddress, apiKey) {
-  if (!apiKey) {
-    throw new Error('Neynar API key is required');
-  }
-  const lowerCasedCustodyAddress = custodyAddress.toLowerCase();
-
-  const response = await fetch(
-    `https://api.neynar.com/v2/farcaster/user/bulk-by-address?addresses=${lowerCasedCustodyAddress}&address_types=custody_address`,
-    {
-      headers: {
-        'accept': 'application/json',
-        'x-api-key': apiKey
-      }
-    }
-  );
-
-  if (!response.ok) {
-    throw new Error(`Failed to lookup FID: ${response.statusText}`);
-  }
-
-  const data = await response.json();
-  if (!data[lowerCasedCustodyAddress]?.length || !data[lowerCasedCustodyAddress][0].custody_address) {
-    throw new Error('No FID found for this custody address');
-  }
-
-  return data[lowerCasedCustodyAddress][0].fid;
-}
-
-async function loadEnvLocal() {
-  try {
-    if (fs.existsSync('.env.local')) {
-      const { loadLocal } = await inquirer.prompt([
-        {
-          type: 'confirm',
-          name: 'loadLocal',
-          message: 'Found .env.local, likely created by the install script - would you like to load its values?',
-          default: false
-        }
-      ]);
-
-      if (loadLocal) {
-        console.log('Loading values from .env.local...');
-        const localEnv = dotenv.parse(fs.readFileSync('.env.local'));
-        
-        // Copy all values except SEED_PHRASE to .env
-        const envContent = fs.existsSync('.env') ? fs.readFileSync('.env', 'utf8') + '\n' : '';
-        let newEnvContent = envContent;
-        
-        for (const [key, value] of Object.entries(localEnv)) {
-          if (key !== 'SEED_PHRASE') {
-            // Update process.env
-            process.env[key] = value;
-            // Add to .env content if not already there
-            if (!envContent.includes(`${key}=`)) {
-              newEnvContent += `${key}="${value}"\n`;
-            }
-          }
-        }
-        
-        // Write updated content to .env
-        fs.writeFileSync('.env', newEnvContent);
-        console.log('✅ Values from .env.local have been written to .env');
-      }
-    }
-
-    // Always try to load SEED_PHRASE from .env.local
-    if (fs.existsSync('.env.local')) {
-      const localEnv = dotenv.parse(fs.readFileSync('.env.local'));
-      if (localEnv.SEED_PHRASE) {
-        process.env.SEED_PHRASE = localEnv.SEED_PHRASE;
-      }
-    }
-  } catch (error) {
-    // Error reading .env.local, which is fine
-    console.log('Note: No .env.local file found');
-  }
-}
-
-// TODO: make sure rebuilding is supported
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const projectRoot = path.join(__dirname, '..');
-
-async function validateDomain(domain) {
-  // Remove http:// or https:// if present
-  const cleanDomain = domain.replace(/^https?:\/\//, '');
-  
-  // Basic domain validation
-  if (!cleanDomain.match(/^[a-zA-Z0-9][a-zA-Z0-9-]{1,61}[a-zA-Z0-9](?:\.[a-zA-Z]{2,})+$/)) {
-    throw new Error('Invalid domain format');
-  }
-
-  return cleanDomain;
-}
-
-async function queryNeynarApp(apiKey) {
-  if (!apiKey) {
-    return null;
-  }
-  try {
-    const response = await fetch(
-      `https://api.neynar.com/portal/app_by_api_key`,
-      {
-        headers: {
-          'x-api-key': apiKey
-        }
-      }
-    );
-    const data = await response.json();
-    return data;
-  } catch (error) {
-    console.error('Error querying Neynar app data:', error);
-    return null;
-  }
-}
-
-async function validateSeedPhrase(seedPhrase) {
-  try {
-    // Try to create an account from the seed phrase
-    const account = mnemonicToAccount(seedPhrase);
-    return account.address;
-  } catch (error) {
-    throw new Error('Invalid seed phrase');
-  }
-}
-
-async function generateFarcasterMetadata(domain, fid, accountAddress, seedPhrase, webhookUrl) {
-  const header = {
-    type: 'custody',
-    key: accountAddress,
-    fid,
-  };
-  const encodedHeader = Buffer.from(JSON.stringify(header), 'utf-8').toString('base64');
-
-  const payload = {
-    domain
-  };
-  const encodedPayload = Buffer.from(JSON.stringify(payload), 'utf-8').toString('base64url');
-
-  const account = mnemonicToAccount(seedPhrase);
-  const signature = await account.signMessage({ 
-    message: `${encodedHeader}.${encodedPayload}`
-  });
-  const encodedSignature = Buffer.from(signature, 'utf-8').toString('base64url');
-
-  const tags = process.env.NEXT_PUBLIC_FRAME_TAGS?.split(',');
-
-  return {
-    accountAssociation: {
-      header: encodedHeader,
-      payload: encodedPayload,
-      signature: encodedSignature
-    },
-    frame: {
-      version: "1",
-      name: process.env.NEXT_PUBLIC_FRAME_NAME,
-      iconUrl: `https://${domain}/icon.png`,
-      homeUrl: `https://${domain}`,
-      imageUrl: `https://${domain}/api/opengraph-image`,
-      buttonTitle: process.env.NEXT_PUBLIC_FRAME_BUTTON_TEXT,
-      splashImageUrl: `https://${domain}/splash.png`,
-      splashBackgroundColor: "#f7f7f7",
-      webhookUrl,
-      description: process.env.NEXT_PUBLIC_FRAME_DESCRIPTION,
-      primaryCategory: process.env.NEXT_PUBLIC_FRAME_PRIMARY_CATEGORY,
-      tags,
-    },
-  };
-}
-
-async function main() {
-  try {
-    console.log('\n📝 Checking environment variables...');
-    console.log('Loading values from .env...');
-    
-    // Load .env.local if user wants to
-    await loadEnvLocal();
-
-    // Get domain from user
-    const { domain } = await inquirer.prompt([
-      {
-        type: 'input',
-        name: 'domain',
-        message: 'Enter the domain where your mini app will be deployed (e.g., example.com):',
-        validate: async (input) => {
-          try {
-            await validateDomain(input);
-            return true;
-          } catch (error) {
-            return error.message;
-          }
-        }
-      }
-    ]);
-
-    // Get frame name from user
-    const { frameName } = await inquirer.prompt([
-      {
-        type: 'input',
-        name: 'frameName',
-        message: 'Enter the name for your mini app (e.g., My Cool Mini App):',
-        default: process.env.NEXT_PUBLIC_FRAME_NAME,
-        validate: (input) => {
-          if (input.trim() === '') {
-            return 'Mini app name cannot be empty';
-          }
-          return true;
-        }
-      }
-    ]);
-
-    // Get button text from user
-    const { buttonText } = await inquirer.prompt([
-      {
-        type: 'input',
-        name: 'buttonText',
-        message: 'Enter the text for your mini app button:',
-        default: process.env.NEXT_PUBLIC_FRAME_BUTTON_TEXT || 'Launch Mini App',
-        validate: (input) => {
-          if (input.trim() === '') {
-            return 'Button text cannot be empty';
-          }
-          return true;
-        }
-      }
-    ]);
-
-    // Get Neynar configuration
-    let neynarApiKey = process.env.NEYNAR_API_KEY;
-    let neynarClientId = process.env.NEYNAR_CLIENT_ID;
-    let useNeynar = true;
-
-    while (useNeynar) {
-      if (!neynarApiKey) {
-        const { neynarApiKey: inputNeynarApiKey } = await inquirer.prompt([
-          {
-            type: 'password',
-            name: 'neynarApiKey',
-            message: 'Enter your Neynar API key (optional - leave blank to skip):',
-            default: null
-          }
-        ]);
-        neynarApiKey = inputNeynarApiKey;
-      } else {
-        console.log('Using existing Neynar API key from .env');
-      }
-
-      if (!neynarApiKey) {
-        useNeynar = false;
-        break;
-      }
-
-      // Try to get client ID from API
-      const appInfo = await queryNeynarApp(neynarApiKey);
-      if (appInfo) {
-        neynarClientId = appInfo.app_uuid;
-        console.log('✅ Fetched Neynar app client ID');
-        break;
-      }
-
-      // If we get here, the API key was invalid
-      console.log('\n⚠️  Could not find Neynar app information. The API key may be incorrect.');
-      const { retry } = await inquirer.prompt([
-        {
-          type: 'confirm',
-          name: 'retry',
-          message: 'Would you like to try a different API key?',
-          default: true
-        }
-      ]);
-
-      // Reset for retry
-      neynarApiKey = null;
-      neynarClientId = null;
-
-      if (!retry) {
-        useNeynar = false;
-        break;
-      }
-    }
-
-    // Get seed phrase from user
-    let seedPhrase = process.env.SEED_PHRASE;
-    if (!seedPhrase) {
-      const { seedPhrase: inputSeedPhrase } = await inquirer.prompt([
-        {
-          type: 'password',
-          name: 'seedPhrase',
-          message: 'Your farcaster custody account seed phrase is required to create a signature proving this app was created by you.\n' +
-          `⚠️ ${yellow}${italic}seed phrase is only used to sign the mini app manifest, then discarded${reset} ⚠️\n` +
-          'Seed phrase:',
-          validate: async (input) => {
-            try {
-              await validateSeedPhrase(input);
-              return true;
-            } catch (error) {
-              return error.message;
-            }
-          }
-        }
-      ]);
-      seedPhrase = inputSeedPhrase;
-    } else {
-      console.log('Using existing seed phrase from .env');
-    }
-
-    // Validate seed phrase and get account address
-    const accountAddress = await validateSeedPhrase(seedPhrase);
-    console.log('✅ Generated account address from seed phrase');
-
-    const fid = await lookupFidByCustodyAddress(accountAddress, neynarApiKey ?? 'FARCASTER_V2_FRAMES_DEMO');
-
-    // Generate and sign manifest
-    console.log('\n🔨 Generating mini app manifest...');
-    
-    // Determine webhook URL based on environment variables
-    const webhookUrl = neynarApiKey && neynarClientId 
-      ? `https://api.neynar.com/f/app/${neynarClientId}/event`
-      : `${domain}/api/webhook`;
-
-    const metadata = await generateFarcasterMetadata(domain, fid, accountAddress, seedPhrase, webhookUrl);
-    console.log('\n✅ Mini app manifest generated' + (seedPhrase ? ' and signed' : ''));
-
-    // Read existing .env file or create new one
-    const envPath = path.join(projectRoot, '.env');
-    let envContent = fs.existsSync(envPath) ? fs.readFileSync(envPath, 'utf8') : '';
-
-    // Add or update environment variables
-    const newEnvVars = [
-      // Base URL
-      `NEXT_PUBLIC_URL=https://${domain}`,
-
-      // Frame metadata
-      `NEXT_PUBLIC_FRAME_NAME="${frameName}"`,
-      `NEXT_PUBLIC_FRAME_DESCRIPTION="${process.env.NEXT_PUBLIC_FRAME_DESCRIPTION || ''}"`,
-      `NEXT_PUBLIC_FRAME_PRIMARY_CATEGORY="${process.env.NEXT_PUBLIC_FRAME_PRIMARY_CATEGORY || ''}"`,
-      `NEXT_PUBLIC_FRAME_TAGS="${process.env.NEXT_PUBLIC_FRAME_TAGS || ''}"`,
-      `NEXT_PUBLIC_FRAME_BUTTON_TEXT="${buttonText}"`,
-
-      // Analytics
-      `NEXT_PUBLIC_ANALYTICS_ENABLED="${process.env.NEXT_PUBLIC_ANALYTICS_ENABLED || 'false'}"`,
-
-      // Neynar configuration (if it exists in current env)
-      ...(process.env.NEYNAR_API_KEY ? 
-        [`NEYNAR_API_KEY="${process.env.NEYNAR_API_KEY}"`] : []),
-      ...(neynarClientId ? 
-        [`NEYNAR_CLIENT_ID="${neynarClientId}"`] : []),
-
-      // FID (if it exists in current env)
-      ...(process.env.FID ? [`FID="${process.env.FID}"`] : []),
-
-      // NextAuth configuration
-      `NEXTAUTH_SECRET="${process.env.NEXTAUTH_SECRET || crypto.randomBytes(32).toString('hex')}"`,
-      `NEXTAUTH_URL="https://${domain}"`,
-
-      // Frame manifest with signature
-      `FRAME_METADATA=${JSON.stringify(metadata)}`,
-    ];
-
-    // Filter out empty values and join with newlines
-    const validEnvVars = newEnvVars.filter(line => {
-      const [, value] = line.split('=');
-      return value && value !== '""';
-    });
-
-    // Update or append each environment variable
-    validEnvVars.forEach(varLine => {
-      const [key] = varLine.split('=');
-      if (envContent.includes(`${key}=`)) {
-        envContent = envContent.replace(new RegExp(`${key}=.*`), varLine);
-      } else {
-        envContent += `\n${varLine}`;
-      }
-    });
-
-    // Write updated .env file
-    fs.writeFileSync(envPath, envContent);
-
-    console.log('\n✅ Environment variables updated');
-
-    // Run next build
-    console.log('\nBuilding Next.js application...');
-    const nextBin = path.normalize(path.join(projectRoot, 'node_modules', '.bin', 'next'));
-    execSync(`"${nextBin}" build`, { 
-      cwd: projectRoot, 
-      stdio: 'inherit',
-      shell: process.platform === 'win32'
-    });
-
-    console.log('\n✨ Build complete! Your mini app is ready for deployment. 🪐');
-    console.log('📝 Make sure to configure the environment variables from .env in your hosting provider');
-
-  } catch (error) {
-    console.error('\n❌ Error:', error.message);
-    process.exit(1);
-  }
-}
-
-main();

scripts/cleanup.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+
+import { execSync } from 'child_process';
+
+// Parse arguments
+const args = process.argv.slice(2);
+let port = 3000; // default port
+
+// Look for --port=XXXX, --port XXXX, -p=XXXX, or -p XXXX
+args.forEach((arg, index) => {
+  if (arg.startsWith('--port=')) {
+    port = arg.split('=')[1];
+  } else if (arg === '--port' && args[index + 1]) {
+    port = args[index + 1];
+  } else if (arg.startsWith('-p=')) {
+    port = arg.split('=')[1];
+  } else if (arg === '-p' && args[index + 1]) {
+    port = args[index + 1];
+  }
+});
+
+try {
+  console.log(`Checking for processes on port ${port}...`);
+
+  // Find processes using the port
+  const pids = execSync(`lsof -ti :${port}`, { encoding: 'utf8' }).trim();
+
+  if (pids) {
+    console.log(`Found processes: ${pids.replace(/\n/g, ', ')}`);
+
+    // Kill the processes
+    execSync(`kill -9 ${pids.replace(/\n/g, ' ')}`);
+    console.log(`✓ Processes on port ${port} have been terminated`);
+  } else {
+    console.log(`No processes found on port ${port}`);
+  }
+} catch (error) {
+  if (error.status === 1) {
+    // lsof returns status 1 when no processes found
+    console.log(`No processes found on port ${port}`);
+  } else {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  }
+}

scripts/deploy.js

@@ -1,676 +0,0 @@
-import { execSync, spawn } from 'child_process';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import inquirer from 'inquirer';
-import dotenv from 'dotenv';
-import crypto from 'crypto';
-import { mnemonicToAccount } from 'viem/accounts';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const projectRoot = path.join(__dirname, '..');
-
-// Load environment variables in specific order
-// First load .env for main config
-dotenv.config({ path: '.env' });
-
-async function validateSeedPhrase(seedPhrase) {
-  try {
-    // Try to create an account from the seed phrase
-    const account = mnemonicToAccount(seedPhrase);
-    return account.address;
-  } catch (error) {
-    throw new Error('Invalid seed phrase');
-  }
-}
-
-async function lookupFidByCustodyAddress(custodyAddress, apiKey) {
-  if (!apiKey) {
-    throw new Error('Neynar API key is required');
-  }
-  const lowerCasedCustodyAddress = custodyAddress.toLowerCase();
-
-  const response = await fetch(
-    `https://api.neynar.com/v2/farcaster/user/bulk-by-address?addresses=${lowerCasedCustodyAddress}&address_types=custody_address`,
-    {
-      headers: {
-        'accept': 'application/json',
-        'x-api-key': apiKey
-      }
-    }
-  );
-
-  if (!response.ok) {
-    throw new Error(`Failed to lookup FID: ${response.statusText}`);
-  }
-
-  const data = await response.json();
-  if (!data[lowerCasedCustodyAddress]?.length || !data[lowerCasedCustodyAddress][0].custody_address) {
-    throw new Error('No FID found for this custody address');
-  }
-
-  return data[lowerCasedCustodyAddress][0].fid;
-}
-
-async function generateFarcasterMetadata(domain, fid, accountAddress, seedPhrase, webhookUrl) {
-  const trimmedDomain = domain.trim();
-  const header = {
-    type: 'custody',
-    key: accountAddress,
-    fid,
-  };
-  const encodedHeader = Buffer.from(JSON.stringify(header), 'utf-8').toString('base64');
-
-  const payload = {
-    domain: trimmedDomain
-  };
-  const encodedPayload = Buffer.from(JSON.stringify(payload), 'utf-8').toString('base64url');
-
-  const account = mnemonicToAccount(seedPhrase);
-  const signature = await account.signMessage({ 
-    message: `${encodedHeader}.${encodedPayload}`
-  });
-  const encodedSignature = Buffer.from(signature, 'utf-8').toString('base64url');
-
-  const tags = process.env.NEXT_PUBLIC_FRAME_TAGS?.split(',');
-
-  return {
-    accountAssociation: {
-      header: encodedHeader,
-      payload: encodedPayload,
-      signature: encodedSignature
-    },
-    frame: {
-      version: "1",
-      name: process.env.NEXT_PUBLIC_FRAME_NAME,
-      iconUrl: `https://${trimmedDomain}/icon.png`,
-      homeUrl: `https://${trimmedDomain}`,
-      imageUrl: `https://${trimmedDomain}/api/opengraph-image`,
-      buttonTitle: process.env.NEXT_PUBLIC_FRAME_BUTTON_TEXT,
-      splashImageUrl: `https://${trimmedDomain}/splash.png`,
-      splashBackgroundColor: "#f7f7f7",
-      webhookUrl: webhookUrl?.trim(),
-      description: process.env.NEXT_PUBLIC_FRAME_DESCRIPTION,
-      primaryCategory: process.env.NEXT_PUBLIC_FRAME_PRIMARY_CATEGORY,
-      tags,
-    },
-  };
-}
-
-async function loadEnvLocal() {
-  try {
-    if (fs.existsSync('.env.local')) {
-      const { loadLocal } = await inquirer.prompt([
-        {
-          type: 'confirm',
-          name: 'loadLocal',
-          message: 'Found .env.local - would you like to load its values in addition to .env values? (except for SEED_PHRASE, values will be written to .env)',
-          default: true
-        }
-      ]);
-
-      if (loadLocal) {
-        console.log('Loading values from .env.local...');
-        const localEnv = dotenv.parse(fs.readFileSync('.env.local'));
-        
-        // Define allowed variables to load from .env.local
-        const allowedVars = [
-          'SEED_PHRASE',
-          'NEXT_PUBLIC_FRAME_NAME',
-          'NEXT_PUBLIC_FRAME_DESCRIPTION',
-          'NEXT_PUBLIC_FRAME_PRIMARY_CATEGORY',
-          'NEXT_PUBLIC_FRAME_TAGS',
-          'NEXT_PUBLIC_FRAME_BUTTON_TEXT',
-          'NEXT_PUBLIC_ANALYTICS_ENABLED',
-          'NEYNAR_API_KEY',
-          'NEYNAR_CLIENT_ID'
-        ];
-        
-        // Copy allowed values except SEED_PHRASE to .env
-        const envContent = fs.existsSync('.env') ? fs.readFileSync('.env', 'utf8') + '\n' : '';
-        let newEnvContent = envContent;
-        
-        for (const [key, value] of Object.entries(localEnv)) {
-          if (allowedVars.includes(key)) {
-            // Update process.env
-            process.env[key] = value;
-            // Add to .env content if not already there (except for SEED_PHRASE)
-            if (key !== 'SEED_PHRASE' && !envContent.includes(`${key}=`)) {
-              newEnvContent += `${key}="${value}"\n`;
-            }
-          }
-        }
-        
-        // Write updated content to .env
-        fs.writeFileSync('.env', newEnvContent);
-        console.log('✅ Values from .env.local have been written to .env');
-      }
-    }
-  } catch (error) {
-    // Error reading .env.local, which is fine
-    console.log('Note: No .env.local file found');
-  }
-}
-
-async function checkRequiredEnvVars() {
-  console.log('\n📝 Checking environment variables...');
-  console.log('Loading values from .env...');
-  
-  // Load .env.local if user wants to
-  await loadEnvLocal();
-
-  const requiredVars = [
-    {
-      name: 'NEXT_PUBLIC_FRAME_NAME',
-      message: 'Enter the name for your frame (e.g., My Cool Mini App):',
-      default: process.env.NEXT_PUBLIC_FRAME_NAME,
-      validate: input => input.trim() !== '' || 'Mini app name cannot be empty'
-    },
-    {
-      name: 'NEXT_PUBLIC_FRAME_BUTTON_TEXT',
-      message: 'Enter the text for your frame button:',
-      default: process.env.NEXT_PUBLIC_FRAME_BUTTON_TEXT ?? 'Launch Mini App',
-      validate: input => input.trim() !== '' || 'Button text cannot be empty'
-    }
-  ];
-
-  const missingVars = requiredVars.filter(varConfig => !process.env[varConfig.name]);
-  
-  if (missingVars.length > 0) {
-    console.log('\n⚠️  Some required information is missing. Let\'s set it up:');
-    for (const varConfig of missingVars) {
-      const { value } = await inquirer.prompt([
-        {
-          type: 'input',
-          name: 'value',
-          message: varConfig.message,
-          default: varConfig.default,
-          validate: varConfig.validate
-        }
-      ]);
-      // Write to both process.env and .env file
-      process.env[varConfig.name] = value;
-      
-      // Read existing .env content
-      const envContent = fs.existsSync('.env') ? fs.readFileSync('.env', 'utf8') : '';
-      
-      // Check if the variable already exists in .env
-      if (!envContent.includes(`${varConfig.name}=`)) {
-        // Append the new variable to .env without extra newlines
-        const newLine = envContent ? '\n' : '';
-        fs.appendFileSync('.env', `${newLine}${varConfig.name}="${value.trim()}"`);
-      }
-    }
-  }
-
-  // Check for seed phrase
-  if (!process.env.SEED_PHRASE) {
-    console.log('\n🔑 Mini App Manifest Signing');
-    console.log('A signed manifest helps users trust your mini app.');
-    const { seedPhrase } = await inquirer.prompt([
-      {
-        type: 'password',
-        name: 'seedPhrase',
-        message: 'Enter your Farcaster custody account seed phrase to sign the mini app manifest\n(optional -- leave blank to create an unsigned mini app)\n\nSeed phrase:',
-        default: null
-      }
-    ]);
-
-    if (seedPhrase) {
-      process.env.SEED_PHRASE = seedPhrase;
-      
-      const { storeSeedPhrase } = await inquirer.prompt([
-        {
-          type: 'confirm',
-          name: 'storeSeedPhrase',
-          message: 'Would you like to store this seed phrase in .env.local for future use?',
-          default: false
-        }
-      ]);
-
-      if (storeSeedPhrase) {
-        // Write to .env.local
-        fs.appendFileSync('.env.local', `\nSEED_PHRASE="${seedPhrase}"`);
-        console.log('✅ Seed phrase stored in .env.local');
-      } else {
-        console.log('ℹ️  Seed phrase will only be used for this deployment');
-      }
-    }
-  }
-}
-
-async function getGitRemote() {
-  try {
-    const remoteUrl = execSync('git remote get-url origin', { 
-      cwd: projectRoot,
-      encoding: 'utf8'
-    }).trim();
-    return remoteUrl;
-  } catch (error) {
-    return null;
-  }
-}
-
-async function checkVercelCLI() {
-  try {
-    execSync('vercel --version', { 
-      stdio: 'ignore',
-      shell: process.platform === 'win32'
-    });
-    return true;
-  } catch (error) {
-    return false;
-  }
-}
-
-async function installVercelCLI() {
-  console.log('Installing Vercel CLI...');
-  execSync('npm install -g vercel', { 
-    stdio: 'inherit',
-    shell: process.platform === 'win32'
-  });
-}
-
-async function loginToVercel() {
-  console.log('\n🔑 Vercel Login');
-  console.log('You can either:');
-  console.log('1. Log in to an existing Vercel account');
-  console.log('2. Create a new Vercel account during login\n');
-  console.log('If creating a new account:');
-  console.log('1. Click "Continue with GitHub"');
-  console.log('2. Authorize GitHub access');
-  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');
-  
-  // Start the login process
-  const child = spawn('vercel', ['login'], {
-    stdio: 'inherit'
-  });
-
-  // Wait for the login process to complete
-  await new Promise((resolve, reject) => {
-    child.on('close', (code) => {
-      if (code === 0) {
-        resolve();
-      } else {
-        // Don't reject here, as the process might exit with non-zero
-        // during the browser auth flow
-        resolve();
-      }
-    });
-  });
-
-  // After the browser flow completes, verify we're actually logged in
-  // Keep checking for up to 5 minutes (increased timeout for new account setup)
-  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.');
-  
-  for (let i = 0; i < 150; i++) {
-    try {
-      execSync('vercel whoami', { stdio: 'ignore' });
-      console.log('✅ Successfully logged in to Vercel!');
-      return true;
-    } catch (error) {
-      if (error.message.includes('Account not found')) {
-        console.log('ℹ️  Waiting for Vercel account setup to complete...');
-      }
-      // Still not logged in, wait 2 seconds before trying again
-      await new Promise(resolve => setTimeout(resolve, 2000));
-    }
-  }
-
-  console.error('\n❌ Login timed out. Please ensure you have:');
-  console.error('1. Completed the Vercel account setup in your browser');
-  console.error('2. Authorized the GitHub integration');
-  console.error('Then try running this script again.');
-  return false;
-}
-
-async function setVercelEnvVar(key, value, projectRoot) {
-  try {
-    // First try to remove the existing env var if it exists
-    try {
-      execSync(`vercel env rm ${key} production -y`, {
-        cwd: projectRoot,
-        stdio: 'ignore',
-        env: process.env
-      });
-    } catch (error) {
-      // Ignore errors from removal (var might not exist)
-    }
-    
-    // For complex objects like frameMetadata, use a temporary file approach
-    if (typeof value === 'object') {
-      const tempFilePath = path.join(projectRoot, `${key}_temp.json`);
-      // Write the value to a temporary file with proper JSON formatting
-      fs.writeFileSync(tempFilePath, JSON.stringify(value));
-      
-      // Use the file to add the environment variable
-      execSync(`vercel env add ${key} production < "${tempFilePath}"`, {
-        cwd: projectRoot,
-        stdio: 'inherit',
-        env: process.env
-      });
-      
-      // Clean up the temporary file
-      fs.unlinkSync(tempFilePath);
-    } else {
-      // For simple string values, use a different approach to avoid shell interpretation issues
-      const tempFilePath = path.join(projectRoot, `${key}_temp.txt`);
-      fs.writeFileSync(tempFilePath, value.toString());
-      
-      execSync(`vercel env add ${key} production < "${tempFilePath}"`, {
-        cwd: projectRoot,
-        stdio: 'inherit',
-        env: process.env
-      });
-      
-      fs.unlinkSync(tempFilePath);
-    }
-    return true;
-  } catch (error) {
-    console.warn(`⚠️  Warning: Failed to set environment variable ${key}:`, error.message);
-    return false;
-  }
-}
-
-async function deployToVercel(useGitHub = false) {
-  try {
-    console.log('\n🚀 Deploying to Vercel...');
-    
-    // Ensure vercel.json exists
-    const vercelConfigPath = path.join(projectRoot, 'vercel.json');
-    if (!fs.existsSync(vercelConfigPath)) {
-      console.log('📝 Creating vercel.json configuration...');
-      fs.writeFileSync(vercelConfigPath, JSON.stringify({
-        buildCommand: "next build",
-        framework: "nextjs"
-      }, null, 2));
-    }
-
-    // TODO: check if project already exists here
-
-    // 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');
-    console.log('\n⚠️ Note: choosing a longer, more unique project name will help avoid conflicts with other existing domains\n');
-    execSync('vercel', { 
-      cwd: projectRoot,
-      stdio: 'inherit',
-      shell: process.platform === 'win32'
-    });
-
-    // Load project info from .vercel/project.json
-    const projectJson = JSON.parse(fs.readFileSync('.vercel/project.json', 'utf8'));
-    const projectId = projectJson.projectId;
-
-    // Get project details using project inspect
-    console.log('\n🔍 Getting project details...');
-    const inspectOutput = execSync(`vercel project inspect ${projectId} 2>&1`, {
-      cwd: projectRoot,
-      encoding: 'utf8'
-    });
-
-    // Extract project name from inspect output
-    let projectName;
-    let domain;
-    const nameMatch = inspectOutput.match(/Name\s+([^\n]+)/);
-    if (nameMatch) {
-      projectName = nameMatch[1].trim();
-      domain = `${projectName}.vercel.app`;
-      console.log('🌐 Using project name for domain:', domain);
-    } else {
-      // Try alternative format
-      const altMatch = inspectOutput.match(/Found Project [^/]+\/([^\n]+)/);
-      if (altMatch) {
-        projectName = altMatch[1].trim();
-        domain = `${projectName}.vercel.app`;
-        console.log('🌐 Using project name for domain:', domain);
-      } else {
-        throw new Error('Could not determine project name from inspection output');
-      }
-    }
-
-    // Generate frame metadata if we have a seed phrase
-    let frameMetadata;
-    let fid;
-    if (process.env.SEED_PHRASE) {
-      console.log('\n🔨 Generating frame metadata...');
-      const accountAddress = await validateSeedPhrase(process.env.SEED_PHRASE);
-      fid = await lookupFidByCustodyAddress(accountAddress, process.env.NEYNAR_API_KEY ?? 'FARCASTER_V2_FRAMES_DEMO');
-      
-      // Determine webhook URL based on Neynar configuration
-      const webhookUrl = process.env.NEYNAR_API_KEY && process.env.NEYNAR_CLIENT_ID 
-        ? `https://api.neynar.com/f/app/${process.env.NEYNAR_CLIENT_ID}/event`
-        : `https://${domain}/api/webhook`;
-
-      frameMetadata = await generateFarcasterMetadata(domain, fid, accountAddress, process.env.SEED_PHRASE, webhookUrl);
-      console.log('✅ Frame metadata generated and signed');
-    }
-
-    // Prepare environment variables
-    const nextAuthSecret = process.env.NEXTAUTH_SECRET || crypto.randomBytes(32).toString('hex');
-    const vercelEnv = {
-      // Required vars
-      NEXTAUTH_SECRET: nextAuthSecret,
-      AUTH_SECRET: nextAuthSecret, // Fallback for some NextAuth versions
-      NEXTAUTH_URL: `https://${domain}`, // Add the deployment URL
-      NEXT_PUBLIC_URL: `https://${domain}`,
-      
-      // Optional vars that should be set if they exist
-      ...(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 }),
-      
-      // Frame metadata - don't stringify here
-      ...(frameMetadata && { FRAME_METADATA: frameMetadata }),
-      
-      // Public vars
-      ...Object.fromEntries(
-        Object.entries(process.env)
-          .filter(([key]) => key.startsWith('NEXT_PUBLIC_'))
-      )
-    };
-
-    // Add or update env vars in Vercel project
-    console.log('\n📝 Setting up environment variables...');
-    for (const [key, value] of Object.entries(vercelEnv)) {
-      if (value) {
-        await setVercelEnvVar(key, value, projectRoot);
-      }
-    }
-
-    // Deploy the project
-    if (useGitHub) {
-      console.log('\nSetting up GitHub integration...');
-      execSync('vercel link', { 
-        cwd: projectRoot,
-        stdio: 'inherit',
-        env: process.env
-      });
-      console.log('\n📦 Deploying with GitHub integration...');
-    } else {
-      console.log('\n📦 Deploying local code directly...');
-    }
-
-    execSync('vercel deploy --prod', { 
-      cwd: projectRoot,
-      stdio: 'inherit',
-      env: process.env
-    });
-    // Verify the actual domain after deployment
-    
-    console.log('\n🔍 Verifying deployment domain...');
-    
-    // Create a temporary file path
-    const tempOutputFile = path.join(projectRoot, 'vercel_output.txt');
-
-    try {
-      // Redirect output to a file
-      execSync(`vercel project ls > "${tempOutputFile}" 2>&1`, {
-        cwd: projectRoot,
-        shell: true
-      });
-      
-      // Read the output file
-      const projectOutput = fs.readFileSync(tempOutputFile, 'utf8');
-
-      // Process the output
-      const projectLines = projectOutput
-        .split('\n')
-        .filter(line => line.includes('https://'));
-      
-      // Find the line containing our project name
-      const currentProject = projectLines.find(line => 
-        line.includes(projectName)
-      );
-      
-      if (currentProject) {
-        // Extract the domain from the line
-        const domainMatch = currentProject.match(/https:\/\/([^\s]+)/);
-        if (domainMatch) {
-          const actualDomain = domainMatch[1];
-          if (actualDomain !== domain) {
-            console.log(`⚠️  Actual domain (${actualDomain}) differs from assumed domain (${domain})`);
-            console.log('🔄 Updating environment variables with correct domain...');
-            
-            // Update domain-dependent environment variables
-            const webhookUrl = process.env.NEYNAR_API_KEY && process.env.NEYNAR_CLIENT_ID 
-              ? `https://api.neynar.com/f/app/${process.env.NEYNAR_CLIENT_ID}/event`
-              : `https://${actualDomain}/api/webhook`;
-
-            if (frameMetadata) {
-              frameMetadata = await generateFarcasterMetadata(actualDomain, fid, await validateSeedPhrase(process.env.SEED_PHRASE), process.env.SEED_PHRASE, webhookUrl);
-              // Update FRAME_METADATA env var using the new function
-              await setVercelEnvVar('FRAME_METADATA', frameMetadata, projectRoot);
-            }
-
-            // Update NEXTAUTH_URL
-            await setVercelEnvVar('NEXTAUTH_URL', `https://${actualDomain}`, projectRoot);
-
-            // Update NEXT_PUBLIC_URL
-            await setVercelEnvVar('NEXT_PUBLIC_URL', `https://${actualDomain}`, projectRoot);
-
-            // Redeploy with updated environment variables
-            console.log('\n📦 Redeploying with correct domain...');
-            execSync('vercel deploy --prod', { 
-              cwd: projectRoot,
-              stdio: 'inherit',
-              env: process.env
-            });
-            
-            domain = actualDomain;
-          }
-        } else {
-          console.warn('⚠️  Could not extract domain from project line');
-        }
-      } else {
-        console.warn('⚠️  Could not find project in Vercel project list');
-      }
-      
-      // Clean up the temporary file
-      fs.unlinkSync(tempOutputFile);
-    } catch (error) {
-      console.error('Error:', error);
-      
-      // Try to read the output file even if there was an error
-      try {
-        if (fs.existsSync(tempOutputFile)) {
-          const errorOutput = fs.readFileSync(tempOutputFile, 'utf8');
-          console.log('Error output file contents:', errorOutput);
-          fs.unlinkSync(tempOutputFile);
-        }
-      } catch (readError) {
-        console.error('Error reading output file:', readError);
-      }
-    }
-    
-    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');
-
-  } catch (error) {
-    console.error('\n❌ Deployment failed:', error.message);
-    process.exit(1);
-  }
-}
-
-async function main() {
-  try {
-    // Print welcome message
-    console.log('🚀 Vercel Mini App Deployment');
-    console.log('This script will deploy your mini app to Vercel.');
-    console.log('\nThe script will:');
-    console.log('1. Check for required environment variables');
-    console.log('2. Set up a Vercel project (new or existing)');
-    console.log('3. Configure environment variables in Vercel');
-    console.log('4. Deploy and build your mini app (Vercel will run the build automatically)\n');
-
-    // Check for required environment variables
-    await checkRequiredEnvVars();
-
-    // Check for git remote
-    const remoteUrl = await getGitRemote();
-    let useGitHub = false;
-
-    if (remoteUrl) {
-      console.log('\n📦 Found GitHub repository:', remoteUrl);
-      const { useGitHubDeploy } = await inquirer.prompt([
-        {
-          type: 'confirm',
-          name: 'useGitHubDeploy',
-          message: 'Would you like to deploy from the GitHub repository?',
-          default: true
-        }
-      ]);
-      useGitHub = useGitHubDeploy;
-    } else {
-      console.log('\n⚠️  No GitHub repository found.');
-      const { action } = await inquirer.prompt([
-        {
-          type: 'list',
-          name: 'action',
-          message: 'What would you like to do?',
-          choices: [
-            { name: 'Deploy local code directly', value: 'deploy' },
-            { name: 'Set up GitHub repository first', value: 'setup' }
-          ],
-          default: 'deploy'
-        }
-      ]);
-
-      if (action === 'setup') {
-        console.log('\n👋 Please set up your GitHub repository first:');
-        console.log('1. Create a new repository on GitHub');
-        console.log('2. Run these commands:');
-        console.log('   git remote add origin <your-repo-url>');
-        console.log('   git push -u origin main');
-        console.log('\nThen run this script again to deploy.');
-        process.exit(0);
-      }
-    }
-
-    // Check and install Vercel CLI if needed
-    if (!await checkVercelCLI()) {
-      console.log('Vercel CLI not found. Installing...');
-      await installVercelCLI();
-    }
-
-    // Login to Vercel
-    console.log('pre login');
-    if (!await loginToVercel()) {
-      console.error('\n❌ Failed to log in to Vercel. Please try again.');
-      process.exit(1);
-    }
-
-    // Deploy to Vercel
-    await deployToVercel(useGitHub);
-
-  } catch (error) {
-    console.error('\n❌ Error:', error.message);
-    process.exit(1);
-  }
-}
-
-main();
-

scripts/deploy.ts

@@ -0,0 +1,963 @@
+import { execSync, spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+import inquirer from 'inquirer';
+import dotenv from 'dotenv';
+import { Vercel } from '@vercel/sdk';
+import { APP_NAME, APP_BUTTON_TEXT } from '../src/lib/constants';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.join(__dirname, '..');
+
+// Load environment variables in specific order
+dotenv.config({ path: '.env' });
+
+async function loadEnvLocal(): Promise<void> {
+  try {
+    if (fs.existsSync('.env.local')) {
+      const { loadLocal }: { loadLocal: boolean } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'loadLocal',
+          message:
+            'Found .env.local - would you like to load its values in addition to .env values?',
+          default: true,
+        },
+      ]);
+
+      if (loadLocal) {
+        console.log('Loading values from .env.local...');
+        const localEnv = dotenv.parse(fs.readFileSync('.env.local'));
+
+        const allowedVars = [
+          'SEED_PHRASE',
+          'NEYNAR_API_KEY',
+          'NEYNAR_CLIENT_ID',
+          'SPONSOR_SIGNER',
+        ];
+
+        const envContent = fs.existsSync('.env')
+          ? fs.readFileSync('.env', 'utf8') + '\n'
+          : '';
+        let newEnvContent = envContent;
+
+        for (const [key, value] of Object.entries(localEnv)) {
+          if (allowedVars.includes(key)) {
+            process.env[key] = value;
+            if (!envContent.includes(`${key}=`)) {
+              newEnvContent += `${key}="${value}"\n`;
+            }
+          }
+        }
+
+        fs.writeFileSync('.env', newEnvContent);
+        console.log('✅ Values from .env.local have been written to .env');
+      }
+    }
+  } catch (error: unknown) {
+    console.log('Note: No .env.local file found');
+  }
+}
+
+async function checkRequiredEnvVars(): Promise<void> {
+  console.log('\n📝 Checking environment variables...');
+  console.log('Loading values from .env...');
+
+  await loadEnvLocal();
+
+  const requiredVars = [
+    {
+      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',
+    },
+    {
+      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',
+    },
+  ];
+
+  const missingVars = requiredVars.filter(
+    varConfig => !process.env[varConfig.name],
+  );
+
+  if (missingVars.length > 0) {
+    console.log("\n⚠️  Some required information is missing. Let's set it up:");
+    for (const varConfig of missingVars) {
+      const { value } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'value',
+          message: varConfig.message,
+          default: varConfig.default,
+          validate: varConfig.validate,
+        },
+      ]);
+
+      process.env[varConfig.name] = value;
+
+      const envContent = fs.existsSync('.env')
+        ? fs.readFileSync('.env', 'utf8')
+        : '';
+
+      if (!envContent.includes(`${varConfig.name}=`)) {
+        const newLine = envContent ? '\n' : '';
+        fs.appendFileSync(
+          '.env',
+          `${newLine}${varConfig.name}="${value.trim()}"`,
+        );
+      }
+
+      // Ask about sponsor signer if SEED_PHRASE is provided
+      if (!process.env.SPONSOR_SIGNER) {
+        const { sponsorSigner } = await inquirer.prompt([
+          {
+            type: 'confirm',
+            name: 'sponsorSigner',
+            message:
+              'Do you want to sponsor the signer? (This will be used in Sign In With Neynar)\n' +
+              'Note: If you choose to sponsor the signer, Neynar will sponsor it for you and you will be charged in CUs.\n' +
+              'For more information, see https://docs.neynar.com/docs/two-ways-to-sponsor-a-farcaster-signer-via-neynar#sponsor-signers',
+            default: false,
+          },
+        ]);
+
+        process.env.SPONSOR_SIGNER = sponsorSigner.toString();
+
+        if (process.env.SEED_PHRASE) {
+          fs.appendFileSync(
+            '.env.local',
+            `\nSPONSOR_SIGNER="${sponsorSigner}"`,
+          );
+          console.log('✅ Sponsor signer preference stored in .env.local');
+        }
+      }
+    }
+  }
+
+  // Load SPONSOR_SIGNER from .env.local if SEED_PHRASE exists but SPONSOR_SIGNER doesn't
+  if (
+    process.env.SEED_PHRASE &&
+    !process.env.SPONSOR_SIGNER &&
+    fs.existsSync('.env.local')
+  ) {
+    const localEnv = dotenv.parse(fs.readFileSync('.env.local'));
+    if (localEnv.SPONSOR_SIGNER) {
+      process.env.SPONSOR_SIGNER = localEnv.SPONSOR_SIGNER;
+    }
+  }
+}
+
+async function getGitRemote(): Promise<string | null> {
+  try {
+    const remoteUrl = execSync('git remote get-url origin', {
+      cwd: projectRoot,
+      encoding: 'utf8',
+    }).trim();
+    return remoteUrl;
+  } catch (error: unknown) {
+    if (error instanceof Error) {
+      return null;
+    }
+    throw error;
+  }
+}
+
+async function checkVercelCLI(): Promise<boolean> {
+  try {
+    execSync('vercel --version', {
+      stdio: 'ignore',
+    });
+    return true;
+  } catch (error: unknown) {
+    if (error instanceof Error) {
+      return false;
+    }
+    throw error;
+  }
+}
+
+async function installVercelCLI(): Promise<void> {
+  console.log('Installing Vercel CLI...');
+  execSync('npm install -g vercel', {
+    stdio: 'inherit',
+  });
+}
+
+async function getVercelToken(): Promise<string | null> {
+  try {
+    // Try to get token from Vercel CLI config
+    const configPath = path.join(os.homedir(), '.vercel', 'auth.json');
+    if (fs.existsSync(configPath)) {
+      const authConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      return authConfig.token;
+    }
+  } catch (error: unknown) {
+    if (error instanceof Error) {
+      console.warn('Could not read Vercel token from config file');
+    }
+  }
+
+  // Try environment variable
+  if (process.env.VERCEL_TOKEN) {
+    return process.env.VERCEL_TOKEN;
+  }
+
+  // Try to extract from vercel whoami
+  try {
+    const whoamiOutput = execSync('vercel whoami', {
+      encoding: 'utf8',
+      stdio: 'pipe',
+    });
+
+    // If we can get whoami, we're logged in, but we need the actual token
+    // The token isn't directly exposed, so we'll need to use CLI for some operations
+    console.log('✅ Verified Vercel CLI authentication');
+    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 error;
+  }
+}
+
+async function loginToVercel(): Promise<boolean> {
+  console.log('\n🔑 Vercel Login');
+  console.log('You can either:');
+  console.log('1. Log in to an existing Vercel account');
+  console.log('2. Create a new Vercel account during login\n');
+  console.log('If creating a new account:');
+  console.log('1. Click "Continue with GitHub"');
+  console.log('2. Authorize GitHub access');
+  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',
+  );
+
+  const child = spawn('vercel', ['login'], {
+    stdio: 'inherit',
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    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.",
+  );
+
+  for (let i = 0; i < 150; i++) {
+    try {
+      execSync('vercel whoami', { stdio: 'ignore' });
+      console.log('✅ Successfully logged in to Vercel!');
+      return true;
+    } catch (error: unknown) {
+      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));
+    }
+  }
+
+  console.error('\n❌ Login timed out. Please ensure you have:');
+  console.error('1. Completed the Vercel account setup in your browser');
+  console.error('2. Authorized the GitHub integration');
+  console.error('Then try running this script again.');
+  return false;
+}
+
+async function setVercelEnvVarSDK(
+  vercelClient: Vercel,
+  projectId: string,
+  key: string,
+  value: string | object,
+): Promise<boolean> {
+  try {
+    let processedValue: string;
+    if (typeof value === 'object') {
+      processedValue = JSON.stringify(value);
+    } else {
+      processedValue = value.toString();
+    }
+
+    // Get existing environment variables
+    const existingVars = await vercelClient.projects.filterProjectEnvs({
+      idOrName: projectId,
+    });
+
+    // 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 && existingVar.id) {
+      // Update existing variable
+      await vercelClient.projects.editProjectEnv({
+        idOrName: projectId,
+        id: existingVar.id,
+        requestBody: {
+          value: processedValue,
+          target: ['production'],
+        },
+      });
+      console.log(`✅ Updated environment variable: ${key}`);
+    } else {
+      // Create new variable
+      await vercelClient.projects.createProjectEnv({
+        idOrName: projectId,
+        requestBody: {
+          key: key,
+          value: processedValue,
+          type: 'encrypted',
+          target: ['production'],
+        },
+      });
+      console.log(`✅ Created environment variable: ${key}`);
+    }
+
+    return true;
+  } catch (error: unknown) {
+    if (error instanceof Error) {
+      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> {
+  try {
+    // Remove existing env var
+    try {
+      execSync(`vercel env rm ${key} production -y`, {
+        cwd: projectRoot,
+        stdio: 'ignore',
+        env: process.env,
+      });
+    } catch (error: unknown) {
+      // Ignore errors from removal
+    }
+
+    let processedValue: string;
+    if (typeof value === 'object') {
+      processedValue = JSON.stringify(value);
+    } else {
+      processedValue = value.toString();
+    }
+
+    // Create temporary file
+    const tempFilePath = path.join(projectRoot, `${key}_temp.txt`);
+    fs.writeFileSync(tempFilePath, processedValue, 'utf8');
+
+    // Use appropriate command based on platform
+    let command: string;
+    if (process.platform === 'win32') {
+      command = `type "${tempFilePath}" | vercel env add ${key} production`;
+    } else {
+      command = `cat "${tempFilePath}" | vercel env add ${key} production`;
+    }
+
+    execSync(command, {
+      cwd: projectRoot,
+      stdio: 'pipe', // Changed from 'inherit' to avoid interactive prompts
+      env: process.env,
+    });
+
+    fs.unlinkSync(tempFilePath);
+    console.log(`✅ Set environment variable: ${key}`);
+    return true;
+  } catch (error: unknown) {
+    const tempFilePath = path.join(projectRoot, `${key}_temp.txt`);
+    if (fs.existsSync(tempFilePath)) {
+      fs.unlinkSync(tempFilePath);
+    }
+    if (error instanceof Error) {
+      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 }>> {
+  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;
+
+    let success = false;
+
+    // Try SDK approach first if we have a Vercel client
+    if (vercelClient && projectId) {
+      success = await setVercelEnvVarSDK(vercelClient, projectId, key, value);
+    }
+
+    // Fallback to CLI approach
+    if (!success) {
+      success = await setVercelEnvVarCLI(key, value, projectRoot);
+    }
+
+    results.push({ key, success });
+  }
+
+  // Report results
+  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}`));
+    console.warn(
+      '\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
+  console.log('\n⏳ Waiting for deployment to complete...');
+  const startTime = Date.now();
+
+  while (Date.now() - startTime < maxWaitTime) {
+    try {
+      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}`);
+
+        if (deployment.state === 'READY') {
+          console.log('✅ Deployment completed successfully!');
+          return deployment;
+        } else if (deployment.state === 'ERROR') {
+          throw new Error(`Deployment failed with state: ${deployment.state}`);
+        } else if (deployment.state === 'CANCELED') {
+          throw new Error('Deployment was canceled');
+        }
+
+        // Still building, wait and check again
+        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));
+      }
+    } catch (error: unknown) {
+      if (error instanceof Error) {
+        console.warn('⚠️  Could not check deployment status:', error.message);
+        await new Promise(resolve => setTimeout(resolve, 5000));
+      }
+      throw error;
+    }
+  }
+
+  throw new Error('Deployment timed out after 5 minutes');
+}
+
+async function deployToVercel(useGitHub = false): Promise<void> {
+  try {
+    console.log('\n🚀 Deploying to Vercel...');
+
+    // Ensure vercel.json exists
+    const vercelConfigPath = path.join(projectRoot, 'vercel.json');
+    if (!fs.existsSync(vercelConfigPath)) {
+      console.log('📝 Creating vercel.json configuration...');
+      fs.writeFileSync(
+        vercelConfigPath,
+        JSON.stringify(
+          {
+            buildCommand: 'next build',
+            framework: 'nextjs',
+          },
+          null,
+          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',
+    );
+    console.log(
+      '\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,
+    });
+
+    await new Promise<void>((resolve, reject) => {
+      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)');
+          resolve(); // Don't reject, as this is often expected
+        }
+      });
+
+      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));
+
+    // Load project info
+    let projectId: string;
+    try {
+      const projectJson = JSON.parse(
+        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 error;
+    }
+
+    // Get Vercel token and initialize SDK client
+    let vercelClient: Vercel | null = null;
+    try {
+      const token = await getVercelToken();
+      if (token) {
+        vercelClient = new Vercel({
+          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',
+        );
+      }
+      throw error;
+    }
+
+    // Get project details
+    console.log('\n🔍 Getting project details...');
+    let domain: string | undefined;
+    let projectName: string | undefined;
+
+    if (vercelClient) {
+      try {
+        const projects = await vercelClient.projects.getProjects({});
+        const project = projects.projects.find(
+          p => 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',
+          );
+        }
+        throw error;
+      }
+    }
+
+    // Fallback to CLI method if SDK failed
+    if (!domain) {
+      try {
+        const inspectOutput = execSync(
+          `vercel project inspect ${projectId} 2>&1`,
+          {
+            cwd: projectRoot,
+            encoding: 'utf8',
+          },
+        );
+
+        const nameMatch = inspectOutput.match(/Name\s+([^\n]+)/);
+        if (nameMatch) {
+          projectName = nameMatch[1].trim();
+          domain = `${projectName}.vercel.app`;
+          console.log('🌐 Using project name for domain:', domain);
+        } else {
+          const altMatch = inspectOutput.match(/Found Project [^/]+\/([^\n]+)/);
+          if (altMatch) {
+            projectName = altMatch[1].trim();
+            domain = `${projectName}.vercel.app`;
+            console.log('🌐 Using project name for domain:', domain);
+          } else {
+            console.warn(
+              '⚠️  Could not determine project name from inspection, using fallback',
+            );
+            // Use a fallback domain based on project ID
+            domain = `project-${projectId.slice(-8)}.vercel.app`;
+            console.log('🌐 Using fallback domain:', domain);
+          }
+        }
+      } catch (error: unknown) {
+        if (error instanceof Error) {
+          console.warn('⚠️  Could not inspect project, using fallback domain');
+          // Use a fallback domain based on project ID
+          domain = `project-${projectId.slice(-8)}.vercel.app`;
+          console.log('🌐 Using fallback domain:', domain);
+        }
+        throw error;
+      }
+    }
+
+    // Prepare environment variables
+    const vercelEnv = {
+      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,
+      }),
+
+      ...Object.fromEntries(
+        Object.entries(process.env).filter(([key]) =>
+          key.startsWith('NEXT_PUBLIC_'),
+        ),
+      ),
+    };
+
+    // Set environment variables
+    await setEnvironmentVariables(
+      vercelClient,
+      projectId,
+      vercelEnv,
+      projectRoot,
+    );
+
+    // Deploy the project
+    if (useGitHub) {
+      console.log('\nSetting up GitHub integration...');
+      execSync('vercel link', {
+        cwd: projectRoot,
+        stdio: 'inherit',
+        env: process.env,
+      });
+      console.log('\n📦 Deploying with GitHub integration...');
+    } else {
+      console.log('\n📦 Deploying local code directly...');
+    }
+
+    // Use spawn for better control over the deployment process
+    const vercelDeploy = spawn('vercel', ['deploy', '--prod'], {
+      cwd: projectRoot,
+      stdio: 'inherit',
+      env: process.env,
+    });
+
+    await new Promise<void>((resolve, reject) => {
+      vercelDeploy.on('close', code => {
+        if (code === 0) {
+          console.log('✅ Vercel deployment command completed');
+          resolve();
+        } else {
+          console.error(`❌ Vercel deployment failed with code: ${code}`);
+          reject(new Error(`Vercel deployment failed with exit code: ${code}`));
+        }
+      });
+
+      vercelDeploy.on('error', error => {
+        console.error('❌ Vercel deployment error:', error.message);
+        reject(error);
+      });
+    });
+
+    // Wait for deployment to actually complete
+    let deployment: any;
+    if (vercelClient) {
+      try {
+        deployment = await waitForDeployment(vercelClient, projectId);
+      } catch (error: unknown) {
+        if (error instanceof Error) {
+          console.warn(
+            '⚠️  Could not verify deployment completion:',
+            error.message,
+          );
+          console.log('ℹ️  Proceeding with domain verification...');
+        }
+        throw error;
+      }
+    }
+
+    // Verify actual domain after deployment
+    console.log('\n🔍 Verifying deployment domain...');
+
+    let actualDomain = domain;
+    if (vercelClient && deployment) {
+      try {
+        actualDomain = deployment.url || domain;
+        console.log('🌐 Verified actual domain:', actualDomain);
+      } catch (error: unknown) {
+        if (error instanceof Error) {
+          console.warn(
+            '⚠️  Could not verify domain via SDK, using assumed domain',
+          );
+        }
+        throw error;
+      }
+    }
+
+    // Update environment variables if domain changed
+    if (actualDomain !== domain) {
+      console.log('🔄 Updating environment variables with correct domain...');
+
+      const updatedEnv: Record<string, string | object> = {
+        NEXT_PUBLIC_URL: `https://${actualDomain}`,
+      };
+
+      await setEnvironmentVariables(
+        vercelClient,
+        projectId,
+        updatedEnv,
+        projectRoot,
+      );
+
+      console.log('\n📦 Redeploying with correct domain...');
+      const vercelRedeploy = spawn('vercel', ['deploy', '--prod'], {
+        cwd: projectRoot,
+        stdio: 'inherit',
+        env: process.env,
+      });
+
+      await new Promise<void>((resolve, reject) => {
+        vercelRedeploy.on('close', code => {
+          if (code === 0) {
+            console.log('✅ Redeployment completed');
+            resolve();
+          } else {
+            console.error(`❌ Redeployment failed with code: ${code}`);
+            reject(new Error(`Redeployment failed with exit code: ${code}`));
+          }
+        });
+
+        vercelRedeploy.on('error', error => {
+          console.error('❌ Redeployment error:', error.message);
+          reject(error);
+        });
+      });
+
+      domain = actualDomain;
+    }
+
+    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',
+    );
+
+    // 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('4. Paste it below when prompted.');
+
+    const { userAccountAssociation } = await inquirer.prompt([
+      {
+        type: 'editor',
+        name: 'userAccountAssociation',
+        message: 'Paste the accountAssociation JSON here:',
+        validate: (input: string) => {
+          try {
+            const parsed = JSON.parse(input);
+            if (parsed.header && parsed.payload && parsed.signature) {
+              return true;
+            }
+            return 'Invalid accountAssociation: must have header, payload, and signature';
+          } catch (e) {
+            return 'Invalid JSON';
+          }
+        },
+      },
+    ]);
+    const parsedAccountAssociation = JSON.parse(userAccountAssociation);
+
+    // Write APP_ACCOUNT_ASSOCIATION to src/lib/constants.ts
+    const constantsPath = path.join(projectRoot, 'src', 'lib', 'constants.ts');
+    let constantsContent = fs.readFileSync(constantsPath, 'utf8');
+
+    // Replace the APP_ACCOUNT_ASSOCIATION line using a robust, anchored, multiline regex
+    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,
+    );
+    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);
+      process.exit(1);
+    }
+    throw error;
+  }
+}
+
+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.',
+    );
+    console.log('\nThe script will:');
+    console.log('1. Check for required environment variables');
+    console.log('2. Set up a Vercel project (new or existing)');
+    console.log('3. Configure environment variables in Vercel using SDK');
+    console.log('4. Deploy and build your mini app\n');
+
+    // Check if @vercel/sdk is installed
+    try {
+      await import('@vercel/sdk');
+    } catch (error: unknown) {
+      if (error instanceof Error) {
+        console.log('📦 Installing @vercel/sdk...');
+        execSync('npm install @vercel/sdk', {
+          cwd: projectRoot,
+          stdio: 'inherit',
+        });
+        console.log('✅ @vercel/sdk installed successfully');
+      }
+      throw error;
+    }
+
+    await checkRequiredEnvVars();
+
+    const remoteUrl = await getGitRemote();
+    let useGitHub = false;
+
+    if (remoteUrl) {
+      console.log('\n📦 Found GitHub repository:', remoteUrl);
+      const { useGitHubDeploy } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'useGitHubDeploy',
+          message: 'Would you like to deploy from the GitHub repository?',
+          default: true,
+        },
+      ]);
+      useGitHub = useGitHubDeploy;
+    } else {
+      console.log('\n⚠️  No GitHub repository found.');
+      const { action } = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'action',
+          message: 'What would you like to do?',
+          choices: [
+            { name: 'Deploy local code directly', value: 'deploy' },
+            { name: 'Set up GitHub repository first', value: 'setup' },
+          ],
+          default: 'deploy',
+        },
+      ]);
+
+      if (action === 'setup') {
+        console.log('\n👋 Please set up your GitHub repository first:');
+        console.log('1. Create a new repository on GitHub');
+        console.log('2. Run these commands:');
+        console.log('   git remote add origin <your-repo-url>');
+        console.log('   git push -u origin main');
+        console.log('\nThen run this script again to deploy.');
+        process.exit(0);
+      }
+    }
+
+    if (!(await checkVercelCLI())) {
+      console.log('Vercel CLI not found. Installing...');
+      await installVercelCLI();
+    }
+
+    if (!(await loginToVercel())) {
+      console.error('\n❌ Failed to log in to Vercel. Please try again.');
+      process.exit(1);
+    }
+
+    await deployToVercel(useGitHub);
+  } catch (error: unknown) {
+    if (error instanceof Error) {
+      console.error('\n❌ Error:', error.message);
+      process.exit(1);
+    }
+    throw error;
+  }
+}
+
+main();

scripts/dev.js

@@ -1,9 +1,9 @@
-import localtunnel from 'localtunnel';
 import { spawn } from 'child_process';
 import { createServer } from 'net';
-import dotenv from 'dotenv';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import dotenv from 'dotenv';
+import localtunnel from 'localtunnel';
 
 // Load environment variables
 dotenv.config({ path: '.env.local' });
@@ -15,8 +15,25 @@ let tunnel;
 let nextDev;
 let isCleaningUp = false;
 
+// Parse command line arguments for port
+const args = process.argv.slice(2);
+let port = 3000; // default port
+
+// Look for --port=XXXX, --port XXXX, -p=XXXX, or -p XXXX
+args.forEach((arg, index) => {
+  if (arg.startsWith('--port=')) {
+    port = parseInt(arg.split('=')[1]);
+  } else if (arg === '--port' && args[index + 1]) {
+    port = parseInt(args[index + 1]);
+  } else if (arg.startsWith('-p=')) {
+    port = parseInt(arg.split('=')[1]);
+  } else if (arg === '-p' && args[index + 1]) {
+    port = parseInt(args[index + 1]);
+  }
+});
+
 async function checkPort(port) {
-  return new Promise((resolve) => {
+  return new Promise(resolve => {
     const server = createServer();
 
     server.once('error', () => {
@@ -37,29 +54,32 @@ async function killProcessOnPort(port) {
     if (process.platform === 'win32') {
       // Windows: Use netstat to find the process
       const netstat = spawn('netstat', ['-ano', '|', 'findstr', `:${port}`]);
-      netstat.stdout.on('data', (data) => {
+      netstat.stdout.on('data', data => {
         const match = data.toString().match(/\s+(\d+)$/);
         if (match) {
           const pid = match[1];
           spawn('taskkill', ['/F', '/PID', pid]);
         }
       });
-      await new Promise((resolve) => netstat.on('close', resolve));
+      await new Promise(resolve => netstat.on('close', resolve));
     } else {
       // Unix-like systems: Use lsof
       const lsof = spawn('lsof', ['-ti', `:${port}`]);
-      lsof.stdout.on('data', (data) => {
-        data.toString().split('\n').forEach(pid => {
-          if (pid) {
-            try {
-              process.kill(parseInt(pid), 'SIGKILL');
-            } catch (e) {
-              if (e.code !== 'ESRCH') throw e;
+      lsof.stdout.on('data', data => {
+        data
+          .toString()
+          .split('\n')
+          .forEach(pid => {
+            if (pid) {
+              try {
+                process.kill(parseInt(pid), 'SIGKILL');
+              } catch (e) {
+                if (e.code !== 'ESRCH') throw e;
+              }
             }
-          }
-        });
+          });
       });
-      await new Promise((resolve) => lsof.on('close', resolve));
+      await new Promise(resolve => lsof.on('close', resolve));
     }
   } catch (e) {
     // Ignore errors if no process found
@@ -67,33 +87,37 @@ async function killProcessOnPort(port) {
 }
 
 async function startDev() {
-  // Check if port 3000 is already in use
-  const isPortInUse = await checkPort(3000);
+  // Check if the specified port is already in use
+  const isPortInUse = await checkPort(port);
   if (isPortInUse) {
-    console.error('Port 3000 is already in use. To find and kill the process using this port:\n\n' +
-      (process.platform === 'win32' 
-        ? '1. Run: netstat -ano | findstr :3000\n' +
-          '2. Note the PID (Process ID) from the output\n' +
-          '3. Run: taskkill /PID <PID> /F\n'
-        : `On macOS/Linux, run:\nnpm run cleanup\n`) +
-      '\nThen try running this command again.');
+    console.error(
+      `Port ${port} is already in use. To find and kill the process using this port:\n\n` +
+        (process.platform === 'win32'
+          ? `1. Run: netstat -ano | findstr :${port}\n` +
+            '2. Note the PID (Process ID) from the output\n' +
+            '3. Run: taskkill /PID <PID> /F\n'
+          : 'On macOS/Linux, run:\nnpm run cleanup\n') +
+        '\nThen try running this command again.',
+    );
     process.exit(1);
   }
 
   const useTunnel = process.env.USE_TUNNEL === 'true';
-  let frameUrl;
+  let miniAppUrl;
 
   if (useTunnel) {
     // Start localtunnel and get URL
-    tunnel = await localtunnel({ port: 3000 });
+    tunnel = await localtunnel({ port: port });
     let ip;
     try {
-      ip = await fetch('https://ipv4.icanhazip.com').then(res => res.text()).then(ip => ip.trim());
+      ip = await fetch('https://ipv4.icanhazip.com')
+        .then(res => res.text())
+        .then(ip => ip.trim());
     } catch (error) {
       console.error('Error getting IP address:', error);
     }
 
-    frameUrl = tunnel.url;
+    miniAppUrl = tunnel.url;
     console.log(`
 🌐 Local tunnel URL: ${tunnel.url}
 
@@ -117,24 +141,26 @@ async function startDev() {
    5. Click "Preview" (note that it may take ~10 seconds to load)
 `);
   } else {
-    frameUrl = 'http://localhost:3000';
+    miniAppUrl = `http://localhost:${port}`;
     console.log(`
 💻 To test your mini app:
    1. Open the Warpcast Mini App Developer Tools: https://warpcast.com/~/developers
    2. Scroll down to the "Preview Mini App" tool
-   3. Enter this URL: ${frameUrl}
+   3. Enter this URL: ${miniAppUrl}
    4. Click "Preview" to test your mini app (note that it may take ~5 seconds to load the first time)
 `);
   }
 
   // Start next dev with appropriate configuration
-  const nextBin = path.normalize(path.join(projectRoot, 'node_modules', '.bin', 'next'));
+  const nextBin = path.normalize(
+    path.join(projectRoot, 'node_modules', '.bin', 'next'),
+  );
 
-  nextDev = spawn(nextBin, ['dev'], {
+  nextDev = spawn(nextBin, ['dev', '-p', port.toString()], {
     stdio: 'inherit',
-    env: { ...process.env, NEXT_PUBLIC_URL: frameUrl, NEXTAUTH_URL: frameUrl },
+    env: { ...process.env, NEXT_PUBLIC_URL: miniAppUrl },
     cwd: projectRoot,
-    shell: process.platform === 'win32' // Add shell option for Windows
+    shell: process.platform === 'win32', // Add shell option for Windows
   });
 
   // Handle cleanup
@@ -174,8 +200,8 @@ async function startDev() {
         }
       }
 
-      // Force kill any remaining processes on port 3000
-      await killProcessOnPort(3000);
+      // Force kill any remaining processes on the specified port
+      await killProcessOnPort(port);
     } catch (error) {
       console.error('Error during cleanup:', error);
     } finally {

src/app/.well-known/farcaster.json/route.ts

@@ -1,9 +1,9 @@
 import { NextResponse } from 'next/server';
-import { getFarcasterMetadata } from '../../../lib/utils';
+import { getFarcasterDomainManifest } from '~/lib/utils';
 
 export async function GET() {
   try {
-    const config = await getFarcasterMetadata();
+    const config = await getFarcasterDomainManifest();
     return NextResponse.json(config);
   } catch (error) {
     console.error('Error generating metadata:', error);

src/app/api/auth/[...nextauth]/route.ts

@@ -1,6 +0,0 @@
-import NextAuth from "next-auth"
-import { authOptions } from "~/auth"
-
-const handler = NextAuth(authOptions)
-
-export { handler as GET, handler as POST }

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 { mnemonicToAccount } from 'viem/accounts';
+import {
+  SIGNED_KEY_REQUEST_TYPE,
+  SIGNED_KEY_REQUEST_VALIDATOR_EIP_712_DOMAIN,
+} from '~/lib/constants';
+import { getNeynarClient } from '~/lib/neynar';
+
+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/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 },
+    );
+  }
+}

src/app/api/best-friends/route.ts

@@ -1,4 +1,3 @@
-import { NeynarAPIClient } from '@neynar/nodejs-sdk';
 import { NextResponse } from 'next/server';
 
 export async function GET(request: Request) {
@@ -8,47 +7,48 @@ export async function GET(request: Request) {
 
   if (!apiKey) {
     return NextResponse.json(
-      { error: 'Neynar API key is not configured. Please add NEYNAR_API_KEY to your environment variables.' },
-      { status: 500 }
+      {
+        error:
+          'Neynar API key is not configured. Please add NEYNAR_API_KEY to your environment variables.',
+      },
+      { status: 500 },
     );
   }
 
   if (!fid) {
     return NextResponse.json(
       { error: 'FID parameter is required' },
-      { status: 400 }
+      { status: 400 },
     );
   }
 
   try {
-    const neynar = new NeynarAPIClient({ apiKey });
-    // TODO: update to use best friends endpoint once SDK merged in
     const response = await fetch(
       `https://api.neynar.com/v2/farcaster/user/best_friends?fid=${fid}&limit=3`,
       {
         headers: {
-          "x-api-key": apiKey,
+          'x-api-key': apiKey,
         },
-      }
+      },
     );
 
     if (!response.ok) {
       throw new Error(`Neynar API error: ${response.statusText}`);
     }
 
-    const { users } = await response.json() as { users: { user: { fid: number; username: string } }[] };
+    const { users } = (await response.json()) as {
+      users: { user: { fid: number; username: string } }[];
+    };
 
-    const bestFriends = users.map(user => ({
-      fid: user.user?.fid,
-      username: user.user?.username,
-    }));
-
-    return NextResponse.json({ bestFriends });
+    return NextResponse.json({ bestFriends: users });
   } catch (error) {
     console.error('Failed to fetch best friends:', error);
     return NextResponse.json(
-      { error: 'Failed to fetch best friends. Please check your Neynar API key and try again.' },
-      { status: 500 }
+      {
+        error:
+          'Failed to fetch best friends. Please check your Neynar API key and try again.',
+      },
+      { status: 500 },
     );
   }
 }

src/app/api/opengraph-image/route.tsx

@@ -1,6 +1,6 @@
-import { ImageResponse } from "next/og";
-import { NextRequest } from "next/server";
-import { getNeynarUser } from "~/lib/neynar";
+import { ImageResponse } from 'next/og';
+import { NextRequest } from 'next/server';
+import { getNeynarUser } from '~/lib/neynar';
 
 export const dynamic = 'force-dynamic';
 
@@ -12,19 +12,27 @@ export async function GET(request: NextRequest) {
 
   return new ImageResponse(
     (
-      <div tw="flex h-full w-full flex-col justify-center items-center relative bg-purple-600">
+      <div tw="flex h-full w-full flex-col justify-center items-center relative bg-primary">
         {user?.pfp_url && (
           <div tw="flex w-96 h-96 rounded-full overflow-hidden mb-8 border-8 border-white">
-            <img src={user.pfp_url} alt="Profile" tw="w-full h-full object-cover" />
+            <img
+              src={user.pfp_url}
+              alt="Profile"
+              tw="w-full h-full object-cover"
+            />
           </div>
         )}
-        <h1 tw="text-8xl text-white">{user?.display_name ? `Hello from ${user.display_name ?? user.username}!` : 'Hello!'}</h1>
+        <h1 tw="text-8xl text-white">
+          {user?.display_name
+            ? `Hello from ${user.display_name ?? user.username}!`
+            : 'Hello!'}
+        </h1>
         <p tw="text-5xl mt-4 text-white opacity-80">Powered by Neynar 🪐</p>
       </div>
     ),
     {
       width: 1200,
       height: 800,
-    }
+    },
   );
 }

src/app/api/send-notification/route.ts

@@ -1,9 +1,9 @@
-import { notificationDetailsSchema } from "@farcaster/frame-sdk";
-import { NextRequest } from "next/server";
-import { z } from "zod";
-import { setUserNotificationDetails } from "~/lib/kv";
-import { sendFrameNotification } from "~/lib/notifs";
-import { sendNeynarFrameNotification } from "~/lib/neynar";
+import { NextRequest } from 'next/server';
+import { notificationDetailsSchema } from '@farcaster/miniapp-sdk';
+import { z } from 'zod';
+import { setUserNotificationDetails } from '~/lib/kv';
+import { sendNeynarMiniAppNotification } from '~/lib/neynar';
+import { sendMiniAppNotification } from '~/lib/notifs';
 
 const requestSchema = z.object({
   fid: z.number(),
@@ -13,7 +13,8 @@ const requestSchema = z.object({
 export async function POST(request: NextRequest) {
   // If Neynar is enabled, we don't need to store notification details
   // as they will be managed by Neynar's system
-  const neynarEnabled = process.env.NEYNAR_API_KEY && process.env.NEYNAR_CLIENT_ID;
+  const neynarEnabled =
+    process.env.NEYNAR_API_KEY && process.env.NEYNAR_CLIENT_ID;
 
   const requestJson = await request.json();
   const requestBody = requestSchema.safeParse(requestJson);
@@ -21,7 +22,7 @@ export async function POST(request: NextRequest) {
   if (requestBody.success === false) {
     return Response.json(
       { success: false, errors: requestBody.error.errors },
-      { status: 400 }
+      { status: 400 },
     );
   }
 
@@ -29,27 +30,29 @@ export async function POST(request: NextRequest) {
   if (!neynarEnabled) {
     await setUserNotificationDetails(
       Number(requestBody.data.fid),
-      requestBody.data.notificationDetails
+      requestBody.data.notificationDetails,
     );
   }
 
   // Use appropriate notification function based on Neynar status
-  const sendNotification = neynarEnabled ? sendNeynarFrameNotification : sendFrameNotification;
+  const sendNotification = neynarEnabled
+    ? sendNeynarMiniAppNotification
+    : sendMiniAppNotification;
   const sendResult = await sendNotification({
     fid: Number(requestBody.data.fid),
-    title: "Test notification",
-    body: "Sent at " + new Date().toISOString(),
+    title: 'Test notification',
+    body: 'Sent at ' + new Date().toISOString(),
   });
 
-  if (sendResult.state === "error") {
+  if (sendResult.state === 'error') {
     return Response.json(
       { success: false, error: sendResult.error },
-      { status: 500 }
+      { status: 500 },
     );
-  } else if (sendResult.state === "rate_limit") {
+  } else if (sendResult.state === 'rate_limit') {
     return Response.json(
-      { success: false, error: "Rate limited" },
-      { status: 429 }
+      { success: false, error: 'Rate limited' },
+      { status: 429 },
     );
   }
 

src/app/api/users/route.ts

@@ -1,5 +1,5 @@
-import { NeynarAPIClient } from '@neynar/nodejs-sdk';
 import { NextResponse } from 'next/server';
+import { NeynarAPIClient } from '@neynar/nodejs-sdk';
 
 export async function GET(request: Request) {
   const apiKey = process.env.NEYNAR_API_KEY;
@@ -8,15 +8,18 @@ export async function GET(request: Request) {
 
   if (!apiKey) {
     return NextResponse.json(
-      { error: 'Neynar API key is not configured. Please add NEYNAR_API_KEY to your environment variables.' },
-      { status: 500 }
+      {
+        error:
+          'Neynar API key is not configured. Please add NEYNAR_API_KEY to your environment variables.',
+      },
+      { status: 500 },
     );
   }
 
   if (!fids) {
     return NextResponse.json(
       { error: 'FIDs parameter is required' },
-      { status: 400 }
+      { status: 400 },
     );
   }
 
@@ -32,8 +35,11 @@ export async function GET(request: Request) {
   } catch (error) {
     console.error('Failed to fetch users:', error);
     return NextResponse.json(
-      { error: 'Failed to fetch users. Please check your Neynar API key and try again.' },
-      { status: 500 }
+      {
+        error:
+          'Failed to fetch users. Please check your Neynar API key and try again.',
+      },
+      { status: 500 },
     );
   }
 }

src/app/api/webhook/route.ts

@@ -1,19 +1,21 @@
+import { NextRequest } from 'next/server';
 import {
   ParseWebhookEvent,
   parseWebhookEvent,
   verifyAppKeyWithNeynar,
-} from "@farcaster/frame-node";
-import { NextRequest } from "next/server";
+} from '@farcaster/miniapp-node';
+import { APP_NAME } from '~/lib/constants';
 import {
   deleteUserNotificationDetails,
   setUserNotificationDetails,
-} from "~/lib/kv";
-import { sendFrameNotification } from "~/lib/notifs";
+} from '~/lib/kv';
+import { sendMiniAppNotification } from '~/lib/notifs';
 
 export async function POST(request: NextRequest) {
   // If Neynar is enabled, we don't need to handle webhooks here
   // as they will be handled by Neynar's webhook endpoint
-  const neynarEnabled = process.env.NEYNAR_API_KEY && process.env.NEYNAR_CLIENT_ID;
+  const neynarEnabled =
+    process.env.NEYNAR_API_KEY && process.env.NEYNAR_CLIENT_ID;
   if (neynarEnabled) {
     return Response.json({ success: true });
   }
@@ -27,24 +29,24 @@ export async function POST(request: NextRequest) {
     const error = e as ParseWebhookEvent.ErrorType;
 
     switch (error.name) {
-      case "VerifyJsonFarcasterSignature.InvalidDataError":
-      case "VerifyJsonFarcasterSignature.InvalidEventDataError":
+      case 'VerifyJsonFarcasterSignature.InvalidDataError':
+      case 'VerifyJsonFarcasterSignature.InvalidEventDataError':
         // The request data is invalid
         return Response.json(
           { success: false, error: error.message },
-          { status: 400 }
+          { status: 400 },
         );
-      case "VerifyJsonFarcasterSignature.InvalidAppKeyError":
+      case 'VerifyJsonFarcasterSignature.InvalidAppKeyError':
         // The app key is invalid
         return Response.json(
           { success: false, error: error.message },
-          { status: 401 }
+          { status: 401 },
         );
-      case "VerifyJsonFarcasterSignature.VerifyAppKeyError":
+      case 'VerifyJsonFarcasterSignature.VerifyAppKeyError':
         // Internal error verifying the app key (caller may want to try again)
         return Response.json(
           { success: false, error: error.message },
-          { status: 500 }
+          { status: 500 },
         );
     }
   }
@@ -55,33 +57,33 @@ export async function POST(request: NextRequest) {
   // Only handle notifications if Neynar is not enabled
   // When Neynar is enabled, notifications are handled through their webhook
   switch (event.event) {
-    case "frame_added":
+    case 'frame_added':
       if (event.notificationDetails) {
         await setUserNotificationDetails(fid, event.notificationDetails);
-        await sendFrameNotification({
+        await sendMiniAppNotification({
           fid,
-          title: "Welcome to Frames v2",
-          body: "Frame is now added to your client",
+          title: `Welcome to ${APP_NAME}`,
+          body: 'Mini app is now added to your client',
         });
       } else {
         await deleteUserNotificationDetails(fid);
       }
       break;
 
-    case "frame_removed":
+    case 'frame_removed':
       await deleteUserNotificationDetails(fid);
       break;
 
-    case "notifications_enabled":
+    case 'notifications_enabled':
       await setUserNotificationDetails(fid, event.notificationDetails);
-      await sendFrameNotification({
+      await sendMiniAppNotification({
         fid,
-        title: "Ding ding ding",
-        body: "Notifications are now enabled",
+        title: `Welcome to ${APP_NAME}`,
+        body: 'Notifications are now enabled',
       });
       break;
 
-    case "notifications_disabled":
+    case 'notifications_disabled':
       await deleteUserNotificationDetails(fid);
       break;
   }

src/app/app.tsx

@@ -1,15 +1,15 @@
-"use client";
+'use client';
 
-import dynamic from "next/dynamic";
-import { APP_NAME } from "~/lib/constants";
+import dynamic from 'next/dynamic';
+import { APP_NAME } from '~/lib/constants';
 
 // note: dynamic import is required for components that use the Frame SDK
-const Demo = dynamic(() => import("~/components/Demo"), {
+const AppComponent = dynamic(() => import('~/components/App'), {
   ssr: false,
 });
 
 export default function App(
-  { title }: { title?: string } = { title: APP_NAME }
+  { title }: { title?: string } = { title: APP_NAME },
 ) {
-  return <Demo title={title} />;
+  return <AppComponent title={title} />;
 }

src/app/globals.css

@@ -1,3 +1,25 @@
+/**
+ * DESIGN SYSTEM - DO NOT EDIT UNLESS NECESSARY
+ * 
+ * This file contains the centralized design system for the mini app.
+ * These component classes establish the visual consistency across all components.
+ * 
+ * ⚠️  AI SHOULD NOT NORMALLY EDIT THIS FILE ⚠️
+ * 
+ * Instead of modifying these classes, AI should:
+ * 1. Use existing component classes (e.g., .btn, .card, .input)
+ * 2. Use Tailwind utilities for one-off styling
+ * 3. Create new React components rather than new CSS classes
+ * 4. Only edit this file for specific bug fixes or accessibility improvements
+ * 
+ * When AI needs to style something:
+ * ✅ Good: <button className="btn btn-primary">Click me</button>
+ * ✅ Good: <div className="bg-primary text-white px-4 py-2 rounded">Custom</div>
+ * ❌ Bad: Adding new CSS classes here for component-specific styling
+ * 
+ * This design system is intentionally minimal to prevent bloat and maintain consistency.
+ */
+
 @tailwind base;
 @tailwind components;
 @tailwind utilities;
@@ -34,3 +56,63 @@ body {
     --radius: 0.5rem;
   }
 }
+
+@layer components {
+  /* Global container styles for consistent layout */
+  .container {
+    @apply mx-auto max-w-md px-4;
+  }
+
+  .container-wide {
+    @apply mx-auto max-w-lg px-4;
+  }
+
+  .container-narrow {
+    @apply mx-auto max-w-sm px-4;
+  }
+
+  /* Global card styles */
+  .card {
+    @apply bg-white dark:bg-gray-800 rounded-lg border border-gray-200 dark:border-gray-700 shadow-sm;
+  }
+
+  .card-primary {
+    @apply bg-primary/10 border-primary/20;
+  }
+
+  /* Global button styles */
+  .btn {
+    @apply inline-flex items-center justify-center rounded-lg px-4 py-2 text-sm font-medium transition-colors focus:outline-none focus:ring-2 focus:ring-offset-2 disabled:opacity-50 disabled:pointer-events-none;
+  }
+
+  .btn-primary {
+    @apply bg-primary text-white hover:bg-primary-dark focus:ring-primary;
+  }
+
+  .btn-secondary {
+    @apply bg-secondary text-gray-900 hover:bg-gray-200 focus:ring-gray-500 dark:bg-secondary-dark dark:text-gray-100 dark:hover:bg-gray-600;
+  }
+
+  .btn-outline {
+    @apply border border-gray-300 bg-transparent hover:bg-gray-50 focus:ring-gray-500 dark:border-gray-600 dark:hover:bg-gray-800;
+  }
+
+  /* Global input styles */
+  .input {
+    @apply block w-full rounded-lg border border-gray-300 bg-white px-3 py-2 text-gray-900 placeholder-gray-500 focus:border-primary focus:outline-none focus:ring-1 focus:ring-primary dark:border-gray-600 dark:bg-gray-800 dark:text-gray-100 dark:placeholder-gray-400;
+  }
+
+  /* Global loading spinner */
+  .spinner {
+    @apply animate-spin rounded-full border-2 border-gray-300 border-t-primary;
+  }
+
+  .spinner-primary {
+    @apply animate-spin rounded-full border-2 border-white border-t-transparent;
+  }
+
+  /* Global focus styles */
+  .focus-ring {
+    @apply focus:outline-none focus:ring-2 focus:ring-primary focus:ring-offset-2;
+  }
+}

src/app/layout.tsx

@@ -1,9 +1,7 @@
-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";
+import type { Metadata } from 'next';
+import '~/app/globals.css';
+import { Providers } from '~/app/providers';
+import { APP_NAME, APP_DESCRIPTION } from '~/lib/constants';
 
 export const metadata: Metadata = {
   title: APP_NAME,
@@ -15,12 +13,10 @@ export default async function RootLayout({
 }: Readonly<{
   children: React.ReactNode;
 }>) {
-  const session = await getSession()
-
   return (
     <html lang="en">
       <body>
-        <Providers session={session}>{children}</Providers>
+        <Providers>{children}</Providers>
       </body>
     </html>
   );

src/app/page.tsx

@@ -1,7 +1,7 @@
-import { Metadata } from "next";
-import App from "./app";
-import { APP_NAME, APP_DESCRIPTION, APP_OG_IMAGE_URL } from "~/lib/constants";
-import { getFrameEmbedMetadata } from "~/lib/utils";
+import { Metadata } from 'next';
+import { APP_NAME, APP_DESCRIPTION, APP_OG_IMAGE_URL } from '~/lib/constants';
+import { getMiniAppEmbedMetadata } from '~/lib/utils';
+import App from './app';
 
 export const revalidate = 300;
 
@@ -14,11 +14,11 @@ export async function generateMetadata(): Promise<Metadata> {
       images: [APP_OG_IMAGE_URL],
     },
     other: {
-      "fc:frame": JSON.stringify(getFrameEmbedMetadata()),
+      'fc:frame': JSON.stringify(getMiniAppEmbedMetadata()),
     },
   };
 }
 
 export default function Home() {
-  return (<App />);
+  return <App />;
 }

src/app/providers.tsx

@@ -1,29 +1,30 @@
-"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 dynamic from 'next/dynamic';
+import { MiniAppProvider } from '@neynar/react';
+import { SafeFarcasterSolanaProvider } from '~/components/providers/SafeFarcasterSolanaProvider';
+import { ANALYTICS_ENABLED } from '~/lib/constants';
 
 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({ children }: { children: React.ReactNode }) {
+  const solanaEndpoint =
+    process.env.SOLANA_RPC_ENDPOINT || 'https://solana-rpc.publicnode.com';
   return (
-    <SessionProvider session={session}>
-      <WagmiProvider>
-        <MiniAppProvider analyticsEnabled={true}>
-          <SafeFarcasterSolanaProvider endpoint={solanaEndpoint}>
-            {children}
-          </SafeFarcasterSolanaProvider>
-        </MiniAppProvider>
-      </WagmiProvider>
-    </SessionProvider>
+    <WagmiProvider>
+      <MiniAppProvider
+        analyticsEnabled={ANALYTICS_ENABLED}
+        backButtonEnabled={true}
+      >
+        <SafeFarcasterSolanaProvider endpoint={solanaEndpoint}>
+          {children}
+        </SafeFarcasterSolanaProvider>
+      </MiniAppProvider>
+    </WagmiProvider>
   );
 }

src/app/share/[fid]/page.tsx

@@ -1,7 +1,7 @@
-import type { Metadata } from "next";
-import { redirect } from "next/navigation";
-import { APP_URL, APP_NAME, APP_DESCRIPTION } from "~/lib/constants";
-import { getFrameEmbedMetadata } from "~/lib/utils";
+import { redirect } from 'next/navigation';
+import type { Metadata } from 'next';
+import { APP_URL, APP_NAME, APP_DESCRIPTION } from '~/lib/constants';
+import { getMiniAppEmbedMetadata } from '~/lib/utils';
 export const revalidate = 300;
 
 // This is an example of how to generate a dynamically generated share page based on fid:
@@ -23,12 +23,12 @@ export async function generateMetadata({
       images: [imageUrl],
     },
     other: {
-      "fc:frame": JSON.stringify(getFrameEmbedMetadata(imageUrl)),
+      'fc:frame': JSON.stringify(getMiniAppEmbedMetadata(imageUrl)),
     },
   };
 }
 
 export default function SharePage() {
   // redirect to home page
-  redirect("/");
+  redirect('/');
 }

src/auth.ts

@@ -1,135 +1,10 @@
-import { AuthOptions, getServerSession } from "next-auth"
-import CredentialsProvider from "next-auth/providers/credentials";
-import { createAppClient, viemConnector } from "@farcaster/auth-client";
+import { sdk } from '@farcaster/miniapp-sdk';
 
-declare module "next-auth" {
-  interface Session {
-    user: {
-      fid: number;
-    };
-  }
-}
-
-function getDomainFromUrl(urlString: string | undefined): string {
-  if (!urlString) {
-    console.warn('NEXTAUTH_URL is not set, using localhost:3000 as fallback');
-    return 'localhost:3000';
-  }
-  try {
-    const url = new URL(urlString);
-    return url.hostname;
-  } catch (error) {
-    console.error('Invalid NEXTAUTH_URL:', urlString, error);
-    console.warn('Using localhost:3000 as fallback');
-    return 'localhost:3000';
-  }
-}
-
-export const authOptions: AuthOptions = {
-    // Configure one or more authentication providers
-  providers: [
-    CredentialsProvider({
-      name: "Sign in with Farcaster",
-      credentials: {
-        message: {
-          label: "Message",
-          type: "text",
-          placeholder: "0x0",
-        },
-        signature: {
-          label: "Signature",
-          type: "text",
-          placeholder: "0x0",
-        },
-        // 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",
-        },
-        pfp: {
-          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');
-          return null;
-        }
-
-        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: csrfToken,
-        });
-        const { success, fid } = verifyResponse;
-
-        if (!success) {
-          return null;
-        }
-
-        return {
-          id: fid.toString(),
-        };
-      },
-    }),
-  ],
-  callbacks: {
-    session: async ({ session, token }) => {
-      if (session?.user) {
-        session.user.fid = parseInt(token.sub ?? '');
-      }
-      return session;
-    },
-  },
-  cookies: {
-    sessionToken: {
-      name: `next-auth.session-token`,
-      options: {
-        httpOnly: true,
-        sameSite: "none",
-        path: "/",
-        secure: true
-      }
-    },
-    callbackUrl: {
-      name: `next-auth.callback-url`,
-      options: {
-        sameSite: "none",
-        path: "/",
-        secure: true
-      }
-    },
-    csrfToken: {
-      name: `next-auth.csrf-token`,
-      options: {
-        httpOnly: true,
-        sameSite: "none",
-        path: "/",
-        secure: true
-      }
-    }
-  }
-}
+// Export QuickAuth from the SDK
+export const quickAuth = sdk.quickAuth;
 
+// Helper function to get session (for server-side compatibility)
 export const getSession = async () => {
-  try {
-    return await getServerSession(authOptions);
-  } catch (error) {
-    console.error('Error getting server session:', error);
-    return null;
-  }
-}
+  // For QuickAuth, sessions are managed by the SDK
+  return null;
+};

src/components/App.tsx

@@ -0,0 +1,126 @@
+'use client';
+
+import { useEffect } from 'react';
+import { useMiniApp } from '@neynar/react';
+import { Footer } from '~/components/ui/Footer';
+import { Header } from '~/components/ui/Header';
+import {
+  HomeTab,
+  ActionsTab,
+  ContextTab,
+  WalletTab,
+} from '~/components/ui/tabs';
+import { USE_WALLET } from '~/lib/constants';
+import { useNeynarUser } from '../hooks/useNeynarUser';
+
+// --- Types ---
+export enum Tab {
+  Home = 'home',
+  Actions = 'actions',
+  Context = 'context',
+  Wallet = 'wallet',
+}
+
+export interface AppProps {
+  title?: string;
+}
+
+/**
+ * App component serves as the main container for the mini app interface.
+ *
+ * This component orchestrates the overall mini app experience by:
+ * - Managing tab navigation and state
+ * - Handling Farcaster mini app initialization
+ * - Coordinating wallet and context state
+ * - Providing error handling and loading states
+ * - Rendering the appropriate tab content based on user selection
+ *
+ * The component integrates with the Neynar SDK for Farcaster functionality
+ * and Wagmi for wallet management. It provides a complete mini app
+ * experience with multiple tabs for different functionality areas.
+ *
+ * Features:
+ * - Tab-based navigation (Home, Actions, Context, Wallet)
+ * - Farcaster mini app integration
+ * - Wallet connection management
+ * - Error handling and display
+ * - Loading states for async operations
+ *
+ * @param props - Component props
+ * @param props.title - Optional title for the mini app (defaults to "Neynar Starter Kit")
+ *
+ * @example
+ * ```tsx
+ * <App title="My Mini App" />
+ * ```
+ */
+export default function App(
+  { title }: AppProps = { title: 'Neynar Starter Kit' },
+) {
+  // --- Hooks ---
+  const { isSDKLoaded, context, setInitialTab, setActiveTab, currentTab } =
+    useMiniApp();
+
+  // --- Neynar user hook ---
+  const { user: neynarUser } = useNeynarUser(context || undefined);
+
+  // --- Effects ---
+  /**
+   * Sets the initial tab to "home" when the SDK is loaded.
+   *
+   * This effect ensures that users start on the home tab when they first
+   * load the mini app. It only runs when the SDK is fully loaded to
+   * prevent errors during initialization.
+   */
+  useEffect(() => {
+    if (isSDKLoaded) {
+      setInitialTab(Tab.Home);
+    }
+  }, [isSDKLoaded, setInitialTab]);
+
+  // --- Early Returns ---
+  if (!isSDKLoaded) {
+    return (
+      <div className="flex items-center justify-center h-screen">
+        <div className="text-center">
+          <div className="spinner h-8 w-8 mx-auto mb-4"></div>
+          <p>Loading SDK...</p>
+        </div>
+      </div>
+    );
+  }
+
+  // --- Render ---
+  return (
+    <div
+      style={{
+        paddingTop: context?.client.safeAreaInsets?.top ?? 0,
+        paddingBottom: context?.client.safeAreaInsets?.bottom ?? 0,
+        paddingLeft: context?.client.safeAreaInsets?.left ?? 0,
+        paddingRight: context?.client.safeAreaInsets?.right ?? 0,
+      }}
+    >
+      {/* Header should be full width */}
+      <Header neynarUser={neynarUser} />
+
+      {/* Main content and footer should be centered */}
+      <div className="container py-2 pb-20">
+        {/* Main title */}
+        <h1 className="text-2xl font-bold text-center mb-4">{title}</h1>
+
+        {/* Tab content rendering */}
+        {currentTab === Tab.Home && <HomeTab />}
+        {currentTab === Tab.Actions && <ActionsTab />}
+        {currentTab === Tab.Context && <ContextTab />}
+        {currentTab === Tab.Wallet && <WalletTab />}
+
+        {/* Footer with navigation */}
+        <Footer
+          activeTab={currentTab as Tab}
+          setActiveTab={setActiveTab}
+          showWallet={USE_WALLET}
+        />
+      </div>
+    </div>
+  );
+}

src/components/Demo.tsx

@@ -1,779 +0,0 @@
-"use client";
-
-import { useCallback, useEffect, useMemo, useState } from "react";
-import { Input } from "../components/ui/input";
-import { signIn, signOut, getCsrfToken } from "next-auth/react";
-import sdk, {
-  SignIn as SignInCore,
-} from "@farcaster/frame-sdk";
-import {
-  useAccount,
-  useSendTransaction,
-  useSignMessage,
-  useSignTypedData,
-  useWaitForTransactionReceipt,
-  useDisconnect,
-  useConnect,
-  useSwitchChain,
-  useChainId,
-} from "wagmi";
-import {
-  useConnection as useSolanaConnection,
-  useWallet as useSolanaWallet,
-} from '@solana/wallet-adapter-react';
-import { useHasSolanaProvider } from "./providers/SafeFarcasterSolanaProvider";
-
-import { config } from "~/components/providers/WagmiProvider";
-import { Button } from "~/components/ui/Button";
-import { truncateAddress } from "~/lib/truncateAddress";
-import { base, degen, mainnet, optimism, unichain } from "wagmi/chains";
-import { BaseError, UserRejectedRequestError } from "viem";
-import { useSession } from "next-auth/react";
-import { useMiniApp } from "@neynar/react";
-import { Label } from "~/components/ui/label";
-import { PublicKey, SystemProgram, Transaction } from '@solana/web3.js';
-import { Header } from "~/components/ui/Header";
-import { Footer } from "~/components/ui/Footer";
-import { USE_WALLET } from "~/lib/constants";
-
-export type Tab = 'home' | 'actions' | 'context' | 'wallet';
-
-export default function Demo(
-  { title }: { title?: string } = { title: "Frames v2 Demo" }
-) {
-  const {
-    isSDKLoaded,
-    context,
-    added,
-    notificationDetails,
-    actions,
-  } = useMiniApp();
-  const [isContextOpen, setIsContextOpen] = useState(false);
-  const [activeTab, setActiveTab] = useState<Tab>('home');
-  const [txHash, setTxHash] = useState<string | null>(null);
-  const [sendNotificationResult, setSendNotificationResult] = useState("");
-  const [copied, setCopied] = useState(false);
-  const [neynarUser, setNeynarUser] = useState<any | null>(null);
-
-  const { address, isConnected } = useAccount();
-  const chainId = useChainId();
-  const hasSolanaProvider = useHasSolanaProvider();
-  let solanaWallet, solanaPublicKey, solanaSignMessage, solanaAddress;
-  if (hasSolanaProvider) {
-    solanaWallet = useSolanaWallet();
-    ({ publicKey: solanaPublicKey, signMessage: solanaSignMessage } = solanaWallet);
-    solanaAddress = solanaPublicKey?.toBase58();
-  }
-
-  useEffect(() => {
-    console.log("isSDKLoaded", isSDKLoaded);
-    console.log("context", context);
-    console.log("address", address);
-    console.log("isConnected", isConnected);
-    console.log("chainId", chainId);
-  }, [context, address, isConnected, chainId, isSDKLoaded]);
-
-  // Fetch Neynar user object when context is available
-  useEffect(() => {
-    const fetchNeynarUserObject = async () => {
-      if (context?.user?.fid) {
-        try {
-          const response = await fetch(`/api/users?fids=${context.user.fid}`);
-          const data = await response.json();
-          if (data.users?.[0]) {
-            setNeynarUser(data.users[0]);
-          }
-        } catch (error) {
-          console.error('Failed to fetch Neynar user object:', error);
-        }
-      }
-    };
-
-    fetchNeynarUserObject();
-  }, [context?.user?.fid]);
-
-  const {
-    sendTransaction,
-    error: sendTxError,
-    isError: isSendTxError,
-    isPending: isSendTxPending,
-  } = useSendTransaction();
-
-  const { isLoading: isConfirming, isSuccess: isConfirmed } =
-    useWaitForTransactionReceipt({
-      hash: txHash as `0x${string}`,
-    });
-
-  const {
-    signTypedData,
-    error: signTypedError,
-    isError: isSignTypedError,
-    isPending: isSignTypedPending,
-  } = useSignTypedData();
-
-  const { disconnect } = useDisconnect();
-  const { connect, connectors } = useConnect();
-
-  const {
-    switchChain,
-    error: switchChainError,
-    isError: isSwitchChainError,
-    isPending: isSwitchChainPending,
-  } = useSwitchChain();
-
-  const nextChain = useMemo(() => {
-    if (chainId === base.id) {
-      return optimism;
-    } else if (chainId === optimism.id) {
-      return degen;
-    } else if (chainId === degen.id) {
-      return mainnet;
-    } else if (chainId === mainnet.id) {
-      return unichain;
-    } else {
-      return base;
-    }
-  }, [chainId]);
-
-  const handleSwitchChain = useCallback(() => {
-    switchChain({ chainId: nextChain.id });
-  }, [switchChain, nextChain.id]);
-
-  const sendNotification = useCallback(async () => {
-    setSendNotificationResult("");
-    if (!notificationDetails || !context) {
-      return;
-    }
-
-    try {
-      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) {
-        setSendNotificationResult("Success");
-        return;
-      } else if (response.status === 429) {
-        setSendNotificationResult("Rate limited");
-        return;
-      }
-
-      const data = await response.text();
-      setSendNotificationResult(`Error: ${data}`);
-    } catch (error) {
-      setSendNotificationResult(`Error: ${error}`);
-    }
-  }, [context, notificationDetails]);
-
-  const sendTx = useCallback(() => {
-    sendTransaction(
-      {
-        // call yoink() on Yoink contract
-        to: "0x4bBFD120d9f352A0BEd7a014bd67913a2007a878",
-        data: "0x9846cd9efc000023c0",
-      },
-      {
-        onSuccess: (hash) => {
-          setTxHash(hash);
-        },
-      }
-    );
-  }, [sendTransaction]);
-
-  const signTyped = useCallback(() => {
-    signTypedData({
-      domain: {
-        name: "Frames v2 Demo",
-        version: "1",
-        chainId,
-      },
-      types: {
-        Message: [{ name: "content", type: "string" }],
-      },
-      message: {
-        content: "Hello from Frames v2!",
-      },
-      primaryType: "Message",
-    });
-  }, [chainId, signTypedData]);
-
-  const toggleContext = useCallback(() => {
-    setIsContextOpen((prev) => !prev);
-  }, []);
-
-  if (!isSDKLoaded) {
-    return <div>Loading...</div>;
-  }
-
-  return (
-    <div
-      style={{
-        paddingTop: context?.client.safeAreaInsets?.top ?? 0,
-        paddingBottom: context?.client.safeAreaInsets?.bottom ?? 0,
-        paddingLeft: context?.client.safeAreaInsets?.left ?? 0,
-        paddingRight: context?.client.safeAreaInsets?.right ?? 0,
-      }}
-    >
-      <div className="mx-auto py-2 px-2 pb-20">
-        <Header neynarUser={neynarUser} />
-
-        <h1 className="text-2xl font-bold text-center mb-4">{title}</h1>
-
-        {activeTab === 'home' && (
-          <div className="flex items-center justify-center h-[calc(100vh-200px)] px-6">
-            <div className="text-center w-full max-w-md mx-auto">
-              <p className="text-lg mb-2">Put your content here!</p>
-              <p className="text-sm text-gray-500">Powered by Neynar 🪐</p>
-            </div>
-          </div>
-        )}
-
-        {activeTab === 'actions' && (
-          <div className="space-y-3 px-6 w-full max-w-md mx-auto">
-            <div className="p-2 bg-gray-100 dark:bg-gray-800 rounded-lg w-full">
-              <pre className="font-mono text-xs whitespace-pre-wrap break-words w-full">
-                sdk.actions.signIn
-              </pre>
-            </div>
-            <SignIn />
-
-            <div className="p-2 bg-gray-100 dark:bg-gray-800 rounded-lg w-full">
-              <pre className="font-mono text-xs whitespace-pre-wrap break-words w-full">
-                sdk.actions.openUrl
-              </pre>
-            </div>
-            <Button onClick={() => actions.openUrl("https://www.youtube.com/watch?v=dQw4w9WgXcQ")} className="w-full">Open Link</Button>
-
-            <div className="p-2 bg-gray-100 dark:bg-gray-800 rounded-lg w-full">
-              <pre className="font-mono text-xs whitespace-pre-wrap break-words w-full">
-                sdk.actions.viewProfile
-              </pre>
-            </div>
-            <ViewProfile />
-
-            <div className="p-2 bg-gray-100 dark:bg-gray-800 rounded-lg w-full">
-              <pre className="font-mono text-xs whitespace-pre-wrap break-words w-full">
-                sdk.actions.close
-              </pre>
-            </div>
-            <Button onClick={actions.close} className="w-full">Close Frame</Button>
-
-            <div className="text-sm w-full">
-              Client fid {context?.client.clientFid},
-              {added ? " frame added to client," : " frame not added to client,"}
-              {notificationDetails
-                ? " notifications enabled"
-                : " notifications disabled"}
-            </div>
-
-            <div className="p-2 bg-gray-100 dark:bg-gray-800 rounded-lg w-full">
-              <pre className="font-mono text-xs whitespace-pre-wrap break-words w-full">
-                sdk.actions.addMiniApp
-              </pre>
-            </div>
-            <Button onClick={actions.addMiniApp} disabled={added} className="w-full">
-              Add frame to client
-            </Button>
-
-            {sendNotificationResult && (
-              <div className="text-sm w-full">
-                Send notification result: {sendNotificationResult}
-              </div>
-            )}
-            <Button onClick={sendNotification} disabled={!notificationDetails} className="w-full">
-              Send notification
-            </Button>
-
-            <Button 
-              onClick={async () => {
-                if (context?.user?.fid) {
-                  const shareUrl = `${process.env.NEXT_PUBLIC_URL}/share/${context.user.fid}`;
-                  await navigator.clipboard.writeText(shareUrl);
-                  setCopied(true);
-                  setTimeout(() => setCopied(false), 2000);
-                }
-              }}
-              disabled={!context?.user?.fid}
-              className="w-full"
-            >
-              {copied ? "Copied!" : "Copy share URL"}
-            </Button>
-          </div>
-        )}
-
-        {activeTab === 'context' && (
-          <div className="mx-6">
-            <h2 className="text-lg font-semibold mb-2">Context</h2>
-            <div className="p-4 bg-gray-100 dark:bg-gray-800 rounded-lg">
-              <pre className="font-mono text-xs whitespace-pre-wrap break-words w-full">
-                {JSON.stringify(context, null, 2)}
-              </pre>
-            </div>
-          </div>
-        )}
-
-        {activeTab === 'wallet' && USE_WALLET && (
-          <div className="space-y-3 px-6 w-full max-w-md mx-auto">
-            {address && (
-              <div className="text-xs w-full">
-                Address: <pre className="inline w-full">{truncateAddress(address)}</pre>
-              </div>
-            )}
-
-            {chainId && (
-              <div className="text-xs w-full">
-                Chain ID: <pre className="inline w-full">{chainId}</pre>
-              </div>
-            )}
-
-            {isConnected ? (
-              <Button
-                onClick={() => disconnect()}
-                className="w-full"
-              >
-                Disconnect
-              </Button>
-            ) : context ? (
-              <Button
-                onClick={() => connect({ connector: connectors[0] })}
-                className="w-full"
-              >
-                Connect
-              </Button>
-            ) : (
-              <div className="space-y-3 w-full">
-                <Button
-                  onClick={() => connect({ connector: connectors[1] })}
-                  className="w-full"
-                >
-                  Connect Coinbase Wallet
-                </Button>
-                <Button
-                  onClick={() => connect({ connector: connectors[2] })}
-                  className="w-full"
-                >
-                  Connect MetaMask
-                </Button>
-              </div>
-            )}
-
-            <SignEvmMessage />
-
-            {isConnected && (
-              <>
-                <SendEth />
-                <Button
-                  onClick={sendTx}
-                  disabled={!isConnected || isSendTxPending}
-                  isLoading={isSendTxPending}
-                  className="w-full"
-                >
-                  Send Transaction (contract)
-                </Button>
-                {isSendTxError && renderError(sendTxError)}
-                {txHash && (
-                  <div className="text-xs w-full">
-                    <div>Hash: {truncateAddress(txHash)}</div>
-                    <div>
-                      Status:{" "}
-                      {isConfirming
-                        ? "Confirming..."
-                        : isConfirmed
-                        ? "Confirmed!"
-                        : "Pending"}
-                    </div>
-                  </div>
-                )}
-                <Button
-                  onClick={signTyped}
-                  disabled={!isConnected || isSignTypedPending}
-                  isLoading={isSignTypedPending}
-                  className="w-full"
-                >
-                  Sign Typed Data
-                </Button>
-                {isSignTypedError && renderError(signTypedError)}
-                <Button
-                  onClick={handleSwitchChain}
-                  disabled={isSwitchChainPending}
-                  isLoading={isSwitchChainPending}
-                  className="w-full"
-                >
-                  Switch to {nextChain.name}
-                </Button>
-                {isSwitchChainError && renderError(switchChainError)}
-              </>
-            )}
-          </div>
-        )}
-
-        <Footer activeTab={activeTab} setActiveTab={setActiveTab} showWallet={USE_WALLET} />
-      </div>
-    </div>
-  );
-}
-
-// Solana functions inspired by farcaster demo
-// https://github.com/farcasterxyz/frames-v2-demo/blob/main/src/components/Demo.tsx
-function SignSolanaMessage({ signMessage }: { signMessage?: (message: Uint8Array) => Promise<Uint8Array> }) {
-  const [signature, setSignature] = useState<string | undefined>();
-  const [signError, setSignError] = useState<Error | undefined>();
-  const [signPending, setSignPending] = useState(false);
-
-  const handleSignMessage = useCallback(async () => {
-    setSignPending(true);
-    try {
-      if (!signMessage) {
-        throw new Error('no Solana signMessage');
-      }
-      const input = new TextEncoder().encode("Hello from Solana!");
-      const signatureBytes = await signMessage(input);
-      const signature = btoa(String.fromCharCode(...signatureBytes));
-      setSignature(signature);
-      setSignError(undefined);
-    } catch (e) {
-      if (e instanceof Error) {
-        setSignError(e);
-      }
-    } finally {
-      setSignPending(false);
-    }
-  }, [signMessage]);
-
-  return (
-    <>
-      <Button
-        onClick={handleSignMessage}
-        disabled={signPending}
-        isLoading={signPending}
-        className="mb-4"
-      >
-        Sign Message
-      </Button>
-      {signError && renderError(signError)}
-      {signature && (
-        <div className="mt-2 text-xs">
-          <div>Signature: {signature}</div>
-        </div>
-      )}
-    </>
-  );
-}
-
-function SendSolana() {
-  const [state, setState] = useState<
-    | { status: 'none' }
-    | { status: 'pending' }
-    | { status: 'error'; error: Error }
-    | { status: 'success'; signature: string }
-  >({ status: 'none' });
-
-  const { connection: solanaConnection } = useSolanaConnection();
-  const { sendTransaction, publicKey } = useSolanaWallet();
-
-  // This should be replaced but including it from the original demo
-  // https://github.com/farcasterxyz/frames-v2-demo/blob/main/src/components/Demo.tsx#L718
-  const ashoatsPhantomSolanaWallet = 'Ao3gLNZAsbrmnusWVqQCPMrcqNi6jdYgu8T6NCoXXQu1';
-
-  const handleSend = useCallback(async () => {
-    setState({ status: 'pending' });
-    try {
-      if (!publicKey) {
-        throw new Error('no Solana publicKey');
-      }
-
-      const { blockhash } = await solanaConnection.getLatestBlockhash();
-      if (!blockhash) {
-        throw new Error('failed to fetch latest Solana blockhash');
-      }
-
-      const fromPubkeyStr = publicKey.toBase58();
-      const toPubkeyStr = ashoatsPhantomSolanaWallet;
-      const transaction = new Transaction();
-      transaction.add(
-        SystemProgram.transfer({
-          fromPubkey: new PublicKey(fromPubkeyStr),
-          toPubkey: new PublicKey(toPubkeyStr),
-          lamports: 0n,
-        }),
-      );
-      transaction.recentBlockhash = blockhash;
-      transaction.feePayer = new PublicKey(fromPubkeyStr);
-
-      const simulation = await solanaConnection.simulateTransaction(transaction);
-      if (simulation.value.err) {
-        // Gather logs and error details for debugging
-        const logs = simulation.value.logs?.join('\n') ?? 'No logs';
-        const errDetail = JSON.stringify(simulation.value.err);
-        throw new Error(`Simulation failed: ${errDetail}\nLogs:\n${logs}`);
-      }
-      const signature = await sendTransaction(transaction, solanaConnection);
-      setState({ status: 'success', signature });
-    } catch (e) {
-      if (e instanceof Error) {
-        setState({ status: 'error', error: e });
-      } else {
-        setState({ status: 'none' });
-      }
-    }
-  }, [sendTransaction, publicKey, solanaConnection]);
-
-  return (
-    <>
-      <Button
-        onClick={handleSend}
-        disabled={state.status === 'pending'}
-        isLoading={state.status === 'pending'}
-        className="mb-4"
-      >
-        Send Transaction (sol)
-      </Button>
-      {state.status === 'error' && renderError(state.error)}
-      {state.status === 'success' && (
-        <div className="mt-2 text-xs">
-          <div>Hash: {truncateAddress(state.signature)}</div>
-        </div>
-      )}
-    </>
-  );
-}
-
-function SignEvmMessage() {
-  const { isConnected } = useAccount();
-  const { connectAsync } = useConnect();
-  const {
-    signMessage,
-    data: signature,
-    error: signError,
-    isError: isSignError,
-    isPending: isSignPending,
-  } = useSignMessage();
-
-  const handleSignMessage = useCallback(async () => {
-    if (!isConnected) {
-      await connectAsync({
-        chainId: base.id,
-        connector: config.connectors[0],
-      });
-    }
-
-    signMessage({ message: "Hello from Frames v2!" });
-  }, [connectAsync, isConnected, signMessage]);
-
-  return (
-    <>
-      <Button
-        onClick={handleSignMessage}
-        disabled={isSignPending}
-        isLoading={isSignPending}
-      >
-        Sign Message
-      </Button>
-      {isSignError && renderError(signError)}
-      {signature && (
-        <div className="mt-2 text-xs">
-          <div>Signature: {signature}</div>
-        </div>
-      )}
-    </>
-  );
-}
-
-function SendEth() {
-  const { isConnected, chainId } = useAccount();
-  const {
-    sendTransaction,
-    data,
-    error: sendTxError,
-    isError: isSendTxError,
-    isPending: isSendTxPending,
-  } = useSendTransaction();
-
-  const { isLoading: isConfirming, isSuccess: isConfirmed } =
-    useWaitForTransactionReceipt({
-      hash: data,
-    });
-
-  const toAddr = useMemo(() => {
-    // Protocol guild address
-    return chainId === base.id
-      ? "0x32e3C7fD24e175701A35c224f2238d18439C7dBC"
-      : "0xB3d8d7887693a9852734b4D25e9C0Bb35Ba8a830";
-  }, [chainId]);
-
-  const handleSend = useCallback(() => {
-    sendTransaction({
-      to: toAddr,
-      value: 1n,
-    });
-  }, [toAddr, sendTransaction]);
-
-  return (
-    <>
-      <Button
-        onClick={handleSend}
-        disabled={!isConnected || isSendTxPending}
-        isLoading={isSendTxPending}
-      >
-        Send Transaction (eth)
-      </Button>
-      {isSendTxError && renderError(sendTxError)}
-      {data && (
-        <div className="mt-2 text-xs">
-          <div>Hash: {truncateAddress(data)}</div>
-          <div>
-            Status:{" "}
-            {isConfirming
-              ? "Confirming..."
-              : isConfirmed
-              ? "Confirmed!"
-              : "Pending"}
-          </div>
-        </div>
-      )}
-    </>
-  );
-}
-
-function SignIn() {
-  const [signingIn, setSigningIn] = useState(false);
-  const [signingOut, setSigningOut] = useState(false);
-  const [signInResult, setSignInResult] = useState<SignInCore.SignInResult>();
-  const [signInFailure, setSignInFailure] = useState<string>();
-  const { data: session, status } = useSession();
-
-  const getNonce = useCallback(async () => {
-    const nonce = await getCsrfToken();
-    if (!nonce) throw new Error("Unable to generate nonce");
-    return nonce;
-  }, []);
-
-  const handleSignIn = useCallback(async () => {
-    try {
-      setSigningIn(true);
-      setSignInFailure(undefined);
-      const nonce = await getNonce();
-      const result = await sdk.actions.signIn({ nonce });
-      setSignInResult(result);
-
-      await signIn("credentials", {
-        message: result.message,
-        signature: result.signature,
-        redirect: false,
-      });
-    } catch (e) {
-      if (e instanceof SignInCore.RejectedByUser) {
-        setSignInFailure("Rejected by user");
-        return;
-      }
-
-      setSignInFailure("Unknown error");
-    } finally {
-      setSigningIn(false);
-    }
-  }, [getNonce]);
-
-  const handleSignOut = useCallback(async () => {
-    try {
-      setSigningOut(true);
-      await signOut({ redirect: false });
-      setSignInResult(undefined);
-    } finally {
-      setSigningOut(false);
-    }
-  }, []);
-
-  return (
-    <>
-      {status !== "authenticated" && (
-        <Button onClick={handleSignIn} disabled={signingIn}>
-          Sign In with Farcaster
-        </Button>
-      )}
-      {status === "authenticated" && (
-        <Button onClick={handleSignOut} disabled={signingOut}>
-          Sign out
-        </Button>
-      )}
-      {session && (
-        <div className="my-2 p-2 text-xs overflow-x-scroll bg-gray-100 rounded-lg font-mono">
-          <div className="font-semibold text-gray-500 mb-1">Session</div>
-          <div className="whitespace-pre">
-            {JSON.stringify(session, null, 2)}
-          </div>
-        </div>
-      )}
-      {signInFailure && !signingIn && (
-        <div className="my-2 p-2 text-xs overflow-x-scroll bg-gray-100 rounded-lg font-mono">
-          <div className="font-semibold text-gray-500 mb-1">SIWF Result</div>
-          <div className="whitespace-pre">{signInFailure}</div>
-        </div>
-      )}
-      {signInResult && !signingIn && (
-        <div className="my-2 p-2 text-xs overflow-x-scroll bg-gray-100 rounded-lg font-mono">
-          <div className="font-semibold text-gray-500 mb-1">SIWF Result</div>
-          <div className="whitespace-pre">
-            {JSON.stringify(signInResult, null, 2)}
-          </div>
-        </div>
-      )}
-    </>
-  );
-}
-
-function ViewProfile() {
-  const [fid, setFid] = useState("3");
-
-  return (
-    <>
-      <div>
-        <Label
-          className="text-xs font-semibold text-gray-500 mb-1"
-          htmlFor="view-profile-fid"
-        >
-          Fid
-        </Label>
-        <Input
-          id="view-profile-fid"
-          type="number"
-          value={fid}
-          className="mb-2"
-          onChange={(e) => {
-            setFid(e.target.value);
-          }}
-          step="1"
-          min="1"
-        />
-      </div>
-      <Button
-        onClick={() => {
-          sdk.actions.viewProfile({ fid: parseInt(fid) });
-        }}
-      >
-        View Profile
-      </Button>
-    </>
-  );
-}
-
-const renderError = (error: Error | null) => {
-  if (!error) return null;
-  if (error instanceof BaseError) {
-    const isUserRejection = error.walk(
-      (e) => e instanceof UserRejectedRequestError
-    );
-
-    if (isUserRejection) {
-      return <div className="text-red-500 text-xs mt-1">Rejected by user.</div>;
-    }
-  }
-
-  return <div className="text-red-500 text-xs mt-1">{error.message}</div>;
-};
-

src/components/providers/SafeFarcasterSolanaProvider.tsx

@@ -1,10 +1,13 @@
-import React, { createContext, useEffect, useState } from "react";
-import dynamic from "next/dynamic";
-import { sdk } from '@farcaster/frame-sdk';
+import React, { createContext, useEffect, useState } from 'react';
+import dynamic from 'next/dynamic';
+import { sdk } from '@farcaster/miniapp-sdk';
 
 const FarcasterSolanaProvider = dynamic(
-  () => import('@farcaster/mini-app-solana').then(mod => mod.FarcasterSolanaProvider),
-  { ssr: false }
+  () =>
+    import('@farcaster/mini-app-solana').then(
+      mod => mod.FarcasterSolanaProvider,
+    ),
+  { ssr: false },
 );
 
 type SafeFarcasterSolanaProviderProps = {
@@ -12,10 +15,15 @@ type SafeFarcasterSolanaProviderProps = {
   children: React.ReactNode;
 };
 
-const SolanaProviderContext = createContext<{ hasSolanaProvider: boolean }>({ hasSolanaProvider: false });
+const SolanaProviderContext = createContext<{ hasSolanaProvider: boolean }>({
+  hasSolanaProvider: false,
+});
 
-export function SafeFarcasterSolanaProvider({ endpoint, children }: SafeFarcasterSolanaProviderProps) {
-  const isClient = typeof window !== "undefined";
+export function SafeFarcasterSolanaProvider({
+  endpoint,
+  children,
+}: SafeFarcasterSolanaProviderProps) {
+  const isClient = typeof window !== 'undefined';
   const [hasSolanaProvider, setHasSolanaProvider] = useState<boolean>(false);
   const [checked, setChecked] = useState<boolean>(false);
 
@@ -48,8 +56,8 @@ export function SafeFarcasterSolanaProvider({ endpoint, children }: SafeFarcaste
     const origError = console.error;
     console.error = (...args) => {
       if (
-        typeof args[0] === "string" &&
-        args[0].includes("WalletConnectionError: could not get Solana provider")
+        typeof args[0] === 'string' &&
+        args[0].includes('WalletConnectionError: could not get Solana provider')
       ) {
         if (!errorShown) {
           origError(...args);

src/components/providers/WagmiProvider.tsx

@@ -1,12 +1,12 @@
-import { createConfig, http, WagmiProvider } from "wagmi";
-import { base, degen, mainnet, optimism, unichain, celo } from "wagmi/chains";
-import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import { farcasterFrame } from "@farcaster/frame-wagmi-connector";
+import React from 'react';
+import { useEffect, useState } from 'react';
+import { farcasterFrame } from '@farcaster/miniapp-wagmi-connector';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { createConfig, http, WagmiProvider } from 'wagmi';
+import { useConnect, useAccount } from 'wagmi';
+import { base, degen, mainnet, optimism, unichain, celo } from 'wagmi/chains';
 import { coinbaseWallet, metaMask } from 'wagmi/connectors';
-import { APP_NAME, APP_ICON_URL, APP_URL } from "~/lib/constants";
-import { useEffect, useState } from "react";
-import { useConnect, useAccount } from "wagmi";
-import React from "react";
+import { APP_NAME, APP_ICON_URL, APP_URL } from '~/lib/constants';
 
 // Custom hook for Coinbase Wallet detection and auto-connection
 function useCoinbaseWalletAutoConnect() {
@@ -17,7 +17,8 @@ function useCoinbaseWalletAutoConnect() {
   useEffect(() => {
     // Check if we're running in Coinbase Wallet
     const checkCoinbaseWallet = () => {
-      const isInCoinbaseWallet = window.ethereum?.isCoinbaseWallet || 
+      const isInCoinbaseWallet =
+        window.ethereum?.isCoinbaseWallet ||
         window.ethereum?.isCoinbaseWalletExtension ||
         window.ethereum?.isCoinbaseWalletBrowser;
       setIsCoinbaseWallet(!!isInCoinbaseWallet);
@@ -70,7 +71,11 @@ export const config = createConfig({
 const queryClient = new QueryClient();
 
 // Wrapper component that provides Coinbase Wallet auto-connection
-function CoinbaseWalletAutoConnect({ children }: { children: React.ReactNode }) {
+function CoinbaseWalletAutoConnect({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
   useCoinbaseWalletAutoConnect();
   return <>{children}</>;
 }
@@ -79,9 +84,7 @@ export default function Provider({ children }: { children: React.ReactNode }) {
   return (
     <WagmiProvider config={config}>
       <QueryClientProvider client={queryClient}>
-        <CoinbaseWalletAutoConnect>
-          {children}
-        </CoinbaseWalletAutoConnect>
+        <CoinbaseWalletAutoConnect>{children}</CoinbaseWalletAutoConnect>
       </QueryClientProvider>
     </WagmiProvider>
   );

src/components/ui/Button.tsx

@@ -1,17 +1,47 @@
 interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
   children: React.ReactNode;
   isLoading?: boolean;
+  variant?: 'primary' | 'secondary' | 'outline';
+  size?: 'sm' | 'md' | 'lg';
 }
 
-export function Button({ children, className = "", isLoading = false, ...props }: ButtonProps) {
+export function Button({
+  children,
+  className = '',
+  isLoading = false,
+  variant = 'primary',
+  size = 'md',
+  ...props
+}: ButtonProps) {
+  const baseClasses = 'btn';
+
+  const variantClasses = {
+    primary: 'btn-primary',
+    secondary: 'btn-secondary',
+    outline: 'btn-outline',
+  };
+
+  const sizeClasses = {
+    sm: 'px-3 py-1.5 text-xs',
+    md: 'px-4 py-2 text-sm',
+    lg: 'px-6 py-3 text-base',
+  };
+
+  const fullWidthClasses = 'w-full max-w-xs mx-auto block';
+
+  const combinedClasses = [
+    baseClasses,
+    variantClasses[variant],
+    sizeClasses[size],
+    fullWidthClasses,
+    className,
+  ].join(' ');
+
   return (
-    <button
-      className={`w-full max-w-xs mx-auto block bg-[#7C65C1] text-white py-3 px-6 rounded-lg transition-colors disabled:opacity-50 disabled:cursor-not-allowed disabled:hover:bg-[#7C65C1] hover:bg-[#6952A3] ${className}`}
-      {...props}
-    >
+    <button className={combinedClasses} {...props}>
       {isLoading ? (
         <div className="flex items-center justify-center">
-          <div className="animate-spin h-5 w-5 border-2 border-white border-t-transparent rounded-full" />
+          <div className="spinner-primary h-5 w-5" />
         </div>
       ) : (
         children

src/components/ui/Footer.tsx

@@ -1,5 +1,5 @@
-import React from "react";
-import type { Tab } from "~/components/Demo";
+import React from 'react';
+import { Tab } from '~/components/App';
 
 interface FooterProps {
   activeTab: Tab;
@@ -7,31 +7,41 @@ interface FooterProps {
   showWallet?: boolean;
 }
 
-export const Footer: React.FC<FooterProps> = ({ activeTab, setActiveTab, showWallet = false }) => (
-  <div className="fixed bottom-0 left-0 right-0 mx-4 mb-4 bg-gray-100 dark:bg-gray-800 border-[3px] border-double border-purple-500 px-2 py-2 rounded-lg z-50">
+export const Footer: React.FC<FooterProps> = ({
+  activeTab,
+  setActiveTab,
+  showWallet = false,
+}) => (
+  <div className="fixed bottom-0 left-0 right-0 mx-4 mb-4 bg-gray-100 dark:bg-gray-800 border-[3px] border-double border-primary px-2 py-2 rounded-lg z-50">
     <div className="flex justify-around items-center h-14">
       <button
-        onClick={() => setActiveTab('home')}
+        onClick={() => setActiveTab(Tab.Home)}
         className={`flex flex-col items-center justify-center w-full h-full ${
-          activeTab === 'home' ? 'text-purple-500' : 'text-gray-500'
+          activeTab === Tab.Home
+            ? 'text-primary dark:text-primary-light'
+            : 'text-gray-500 dark:text-gray-400'
         }`}
       >
         <span className="text-xl">🏠</span>
         <span className="text-xs mt-1">Home</span>
       </button>
       <button
-        onClick={() => setActiveTab('actions')}
+        onClick={() => setActiveTab(Tab.Actions)}
         className={`flex flex-col items-center justify-center w-full h-full ${
-          activeTab === 'actions' ? 'text-purple-500' : 'text-gray-500'
+          activeTab === Tab.Actions
+            ? 'text-primary dark:text-primary-light'
+            : 'text-gray-500 dark:text-gray-400'
         }`}
       >
         <span className="text-xl">⚡</span>
         <span className="text-xs mt-1">Actions</span>
       </button>
       <button
-        onClick={() => setActiveTab('context')}
+        onClick={() => setActiveTab(Tab.Context)}
         className={`flex flex-col items-center justify-center w-full h-full ${
-          activeTab === 'context' ? 'text-purple-500' : 'text-gray-500'
+          activeTab === Tab.Context
+            ? 'text-primary dark:text-primary-light'
+            : 'text-gray-500 dark:text-gray-400'
         }`}
       >
         <span className="text-xl">📋</span>
@@ -39,9 +49,11 @@ export const Footer: React.FC<FooterProps> = ({ activeTab, setActiveTab, showWal
       </button>
       {showWallet && (
         <button
-          onClick={() => setActiveTab('wallet')}
+          onClick={() => setActiveTab(Tab.Wallet)}
           className={`flex flex-col items-center justify-center w-full h-full ${
-            activeTab === 'wallet' ? 'text-purple-500' : 'text-gray-500'
+            activeTab === Tab.Wallet
+              ? 'text-primary dark:text-primary-light'
+              : 'text-gray-500 dark:text-gray-400'
           }`}
         >
           <span className="text-xl">👛</span>

src/components/ui/Header.tsx

@@ -1,40 +1,38 @@
-"use client";
+'use client';
 
-import { useState } from "react";
-import { APP_NAME } from "~/lib/constants";
-import sdk from "@farcaster/frame-sdk";
-import { useMiniApp } from "@neynar/react";
+import { useState } from 'react';
+import Image from 'next/image';
+import sdk from '@farcaster/miniapp-sdk';
+import { useMiniApp } from '@neynar/react';
+import { APP_NAME } from '~/lib/constants';
 
 type HeaderProps = {
-  neynarUser: any;
+  neynarUser?: {
+    fid: number;
+    score: number;
+  } | null;
 };
 
 export function Header({ neynarUser }: HeaderProps) {
   const { context } = useMiniApp();
   const [isUserDropdownOpen, setIsUserDropdownOpen] = useState(false);
-  const [hasClickedPfp, setHasClickedPfp] = useState(false);
 
   return (
     <div className="relative">
-      <div 
-        className="mb-1 py-2 px-3 bg-gray-100 dark:bg-gray-800 rounded-lg flex items-center justify-between border-[3px] border-double border-purple-500"
-      >
-        <div className="text-lg font-light">
-          Welcome to {APP_NAME}!
-        </div>
+      <div className="mt-4 mb-4 mx-4 px-2 py-2 bg-gray-100 dark:bg-gray-800 rounded-lg flex items-center justify-between border-[3px] border-double border-primary">
+        <div className="text-lg font-light">Welcome to {APP_NAME}!</div>
         {context?.user && (
           <div
             className="cursor-pointer"
             onClick={() => {
               setIsUserDropdownOpen(!isUserDropdownOpen);
-              setHasClickedPfp(true);
             }}
           >
             {context.user.pfpUrl && (
-              <img 
+              <Image
                 src={context.user.pfpUrl}
                 alt="Profile"
-                className="w-10 h-10 rounded-full border-2 border-purple-500"
+                className="w-10 h-10 rounded-full border-2 border-primary"
               />
             )}
           </div>
@@ -42,19 +40,15 @@ export function Header({ neynarUser }: HeaderProps) {
       </div>
       {context?.user && (
         <>
-          {!hasClickedPfp && (
-            <div className="absolute right-0 -bottom-6 text-xs text-purple-500 flex items-center justify-end gap-1 pr-2">
-              <span className="text-[10px]">↑</span> Click PFP! <span className="text-[10px]">↑</span>
-            </div>
-          )}
-          
           {isUserDropdownOpen && (
-            <div className="absolute top-full right-0 z-50 w-fit mt-1 bg-white dark:bg-gray-800 rounded-lg shadow-lg border border-gray-200 dark:border-gray-700">
+            <div className="absolute top-full right-0 z-50 w-fit mt-1 mx-4 bg-white dark:bg-gray-800 rounded-lg shadow-lg border border-gray-200 dark:border-gray-700">
               <div className="p-3 space-y-2">
                 <div className="text-right">
                   <h3
                     className="font-bold text-sm hover:underline cursor-pointer inline-block"
-                    onClick={() => sdk.actions.viewProfile({ fid: context.user.fid })}
+                    onClick={() =>
+                      sdk.actions.viewProfile({ fid: context.user.fid })
+                    }
                   >
                     {context.user.displayName || context.user.username}
                   </h3>

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-[100] 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,98 @@
+'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.username.trim() !== ''
+      ? userData.username
+      : `!${userData?.fid}`;
+  const pfpUrl =
+    userData?.pfpUrl && userData.pfpUrl.trim() !== ''
+      ? 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,666 @@
+'use client';
+
+import '@farcaster/auth-kit/styles.css';
+import { useSignIn } from '@farcaster/auth-kit';
+import { useCallback, useEffect, useState } from 'react';
+import { cn } from '~/lib/utils';
+import { Button } from '~/components/ui/Button';
+import { AuthDialog } from '~/components/ui/NeynarAuthButton/AuthDialog';
+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/miniapp-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);
+
+  // 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) => {
+      const interval = setInterval(async () => {
+        try {
+          const response = await fetch(
+            `/api/auth/signer?signerUuid=${signerUuid}`,
+          );
+
+          if (!response.ok) {
+            throw new Error('Failed to poll signer 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]
+  );
+
+  // Cleanup polling on unmount
+  useEffect(() => {
+    return () => {
+      if (pollingInterval) {
+        clearInterval(pollingInterval);
+      }
+    };
+  }, [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: unknown) => {
+      if (!useBackendFlow) {
+        // Only handle localStorage for frontend flow
+        const existingAuth = getItem<StoredAuthState>(STORAGE_KEY);
+        const user = await fetchUserData(res.fid);
+        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);
+  }, [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) {
+      const handleSignerFlow = async () => {
+        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/',
+                  'farcaster://'
+                )
+              );
+            } 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);
+        }
+      };
+
+      handleSignerFlow();
+    }
+  }, [
+    message,
+    signature,
+    fetchAllSigners,
+    createSigner,
+    generateSignedKeyRequest,
+    startPolling,
+    context,
+    useBackendFlow,
+  ]);
+
+  // 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);
+      }
+    } 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/Share.tsx

@@ -1,12 +1,20 @@
 'use client';
 
 import { useCallback, useState, useEffect } from 'react';
-import { Button } from './Button';
+import { type ComposeCast } from '@farcaster/miniapp-sdk';
 import { useMiniApp } from '@neynar/react';
-import { type ComposeCast } from "@farcaster/frame-sdk";
+import { APP_URL } from '~/lib/constants';
+import { Button } from './Button';
 
-interface CastConfig extends ComposeCast.Options {
+interface EmbedConfig {
+  path?: string;
+  url?: string;
+  imageUrl?: () => Promise<string>;
+}
+
+interface CastConfig extends Omit<ComposeCast.Options, 'embeds'> {
   bestFriends?: boolean;
+  embeds?: (string | EmbedConfig)[];
 }
 
 interface ShareButtonProps {
@@ -16,20 +24,28 @@ interface ShareButtonProps {
   isLoading?: boolean;
 }
 
-export function ShareButton({ buttonText, cast, className = '', isLoading = false }: ShareButtonProps) {
+export function ShareButton({
+  buttonText,
+  cast,
+  className = '',
+  isLoading = false,
+}: ShareButtonProps) {
   const [isProcessing, setIsProcessing] = useState(false);
-  const [bestFriends, setBestFriends] = useState<{ fid: number; username: string; }[] | null>(null);
+  const [bestFriends, setBestFriends] = useState<
+    { fid: number; username: string }[] | null
+  >(null);
+  const [isLoadingBestFriends, setIsLoadingBestFriends] = useState(false);
   const { context, actions } = useMiniApp();
 
   // Fetch best friends if needed
   useEffect(() => {
     if (cast.bestFriends && context?.user?.fid) {
-      setIsProcessing(true);
+      setIsLoadingBestFriends(true);
       fetch(`/api/best-friends?fid=${context.user.fid}`)
         .then(res => res.json())
         .then(data => setBestFriends(data.bestFriends))
         .catch(err => console.error('Failed to fetch best friends:', err))
-        .finally(() => setIsProcessing(false));
+        .finally(() => setIsLoadingBestFriends(false));
     }
   }, [cast.bestFriends, context?.user?.fid]);
 
@@ -40,30 +56,38 @@ export function ShareButton({ buttonText, cast, className = '', isLoading = fals
       let finalText = cast.text || '';
 
       // Process best friends if enabled and data is loaded
-      if (cast.bestFriends && bestFriends) {
-        // Replace @N with usernames
-        finalText = finalText.replace(/@\d+/g, (match) => {
-          const friendIndex = parseInt(match.slice(1)) - 1;
-          const friend = bestFriends[friendIndex];
-          if (friend) {
-            return `@${friend.username}`;
-          }
-          return match;
-        });
+      if (cast.bestFriends) {
+        if (bestFriends) {
+          // Replace @N with usernames, or remove if no matching friend
+          finalText = finalText.replace(/@\d+/g, match => {
+            const friendIndex = parseInt(match.slice(1)) - 1;
+            const friend = bestFriends[friendIndex];
+            if (friend) {
+              return `@${friend.username}`;
+            }
+            return ''; // Remove @N if no matching friend
+          });
+        } else {
+          // If bestFriends is not loaded but bestFriends is enabled, remove @N patterns
+          finalText = finalText.replace(/@\d+/g, '');
+        }
       }
 
       // Process embeds
       const processedEmbeds = await Promise.all(
-        (cast.embeds || []).map(async (embed) => {
+        (cast.embeds || []).map(async embed => {
           if (typeof embed === 'string') {
             return embed;
           }
           if (embed.path) {
-            const baseUrl = process.env.NEXT_PUBLIC_URL || window.location.origin;
+            const baseUrl = APP_URL || window.location.origin;
             const url = new URL(`${baseUrl}${embed.path}`);
 
             // Add UTM parameters
-            url.searchParams.set('utm_source', `share-cast-${context?.user?.fid || 'unknown'}`);
+            url.searchParams.set(
+              'utm_source',
+              `share-cast-${context?.user?.fid || 'unknown'}`,
+            );
 
             // If custom image generator is provided, use it
             if (embed.imageUrl) {
@@ -74,7 +98,7 @@ export function ShareButton({ buttonText, cast, className = '', isLoading = fals
             return url.toString();
           }
           return embed.url || '';
-        })
+        }),
       );
 
       // Open cast composer with all supported intents
@@ -82,9 +106,9 @@ export function ShareButton({ buttonText, cast, className = '', isLoading = fals
         text: finalText,
         embeds: processedEmbeds as [string] | [string, string] | undefined,
         parent: cast.parent,
-        channel: cast.channelKey,
+        channelKey: cast.channelKey,
         close: cast.close,
-      }, 'share-button');
+      });
     } catch (error) {
       console.error('Failed to share:', error);
     } finally {
@@ -92,14 +116,12 @@ export function ShareButton({ buttonText, cast, className = '', isLoading = fals
     }
   }, [cast, bestFriends, context?.user?.fid, actions]);
 
-  const isButtonDisabled = cast.bestFriends && !bestFriends;
-
   return (
     <Button
       onClick={handleShare}
       className={className}
       isLoading={isLoading || isProcessing}
-      disabled={isButtonDisabled}
+      disabled={isLoadingBestFriends}
     >
       {buttonText}
     </Button>

src/components/ui/input.tsx

@@ -1,22 +1,21 @@
-import * as React from "react"
+import * as React from 'react';
+import { cn } from '~/lib/utils';
 
-import { cn } from "~/lib/utils"
-
-const Input = React.forwardRef<HTMLInputElement, React.ComponentProps<"input">>(
+const Input = React.forwardRef<HTMLInputElement, React.ComponentProps<'input'>>(
   ({ className, type, ...props }, ref) => {
     return (
       <input
         type={type}
         className={cn(
-          "flex h-10 w-full rounded-md border border-neutral-200 bg-white px-3 py-2 text-base ring-offset-white file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-neutral-950 placeholder:text-neutral-500 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-neutral-950 focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 md:text-sm dark:border-neutral-800 dark:bg-neutral-950 dark:ring-offset-neutral-950 dark:file:text-neutral-50 dark:placeholder:text-neutral-400 dark:focus-visible:ring-neutral-300",
-          className
+          'flex h-10 w-full rounded-md border border-neutral-200 bg-white px-3 py-2 text-base ring-offset-white file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-neutral-950 placeholder:text-neutral-500 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-neutral-950 focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 md:text-sm dark:border-neutral-800 dark:bg-neutral-950 dark:ring-offset-neutral-950 dark:file:text-neutral-50 dark:placeholder:text-neutral-400 dark:focus-visible:ring-neutral-300',
+          className,
         )}
         ref={ref}
         {...props}
       />
-    )
-  }
-)
-Input.displayName = "Input"
+    );
+  },
+);
+Input.displayName = 'Input';
 
-export { Input }
+export { Input };

src/components/ui/label.tsx

@@ -1,14 +1,13 @@
-"use client"
+'use client';
 
-import * as React from "react"
-import * as LabelPrimitive from "@radix-ui/react-label"
-import { cva, type VariantProps } from "class-variance-authority"
-
-import { cn } from "~/lib/utils"
+import * as React from 'react';
+import * as LabelPrimitive from '@radix-ui/react-label';
+import { cva, type VariantProps } from 'class-variance-authority';
+import { cn } from '~/lib/utils';
 
 const labelVariants = cva(
-  "text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70"
-)
+  'text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70',
+);
 
 const Label = React.forwardRef<
   React.ElementRef<typeof LabelPrimitive.Root>,
@@ -20,7 +19,7 @@ const Label = React.forwardRef<
     className={cn(labelVariants(), className)}
     {...props}
   />
-))
-Label.displayName = LabelPrimitive.Root.displayName
+));
+Label.displayName = LabelPrimitive.Root.displayName;
 
-export { Label }
+export { Label };

src/components/ui/tabs/ActionsTab.tsx

@@ -0,0 +1,217 @@
+'use client';
+
+import { useCallback, useState } from 'react';
+import { type Haptics } from '@farcaster/miniapp-sdk';
+import { useMiniApp } from '@neynar/react';
+import { APP_URL } from '~/lib/constants';
+import { Button } from '../Button';
+import { ShareButton } from '../Share';
+import { SignIn } from '../wallet/SignIn';
+
+// Optional import for NeynarAuthButton - may not exist in all templates
+let NeynarAuthButton: React.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.
+ *
+ * This component provides the main interaction interface for users to:
+ * - Share the mini app with others
+ * - Sign in with Farcaster
+ * - Send notifications to their account
+ * - 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 />
+ * ```
+ */
+export function ActionsTab() {
+  // --- Hooks ---
+  const { actions, added, notificationDetails, haptics, context } =
+    useMiniApp();
+
+  // --- State ---
+  const [notificationState, setNotificationState] = useState({
+    sendStatus: '',
+    shareUrlCopied: false,
+  });
+  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: '' }));
+    if (!notificationDetails || !context) {
+      return;
+    }
+    try {
+      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' }));
+        return;
+      } else if (response.status === 429) {
+        setNotificationState(prev => ({
+          ...prev,
+          sendStatus: 'Rate limited',
+        }));
+        return;
+      }
+      const responseText = await response.text();
+      setNotificationState(prev => ({
+        ...prev,
+        sendStatus: `Error: ${responseText}`,
+      }));
+    } catch (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.
+   */
+  const copyUserShareUrl = useCallback(async () => {
+    if (context?.user?.fid) {
+      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,
+      );
+    }
+  }, [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.
+   */
+  const triggerHapticFeedback = useCallback(async () => {
+    try {
+      await haptics.impactOccurred(selectedHapticIntensity);
+    } catch (error) {
+      console.error('Haptic feedback failed:', error);
+    }
+  }, [haptics, selectedHapticIntensity]);
+
+  // --- Render ---
+  return (
+    <div className="space-y-3 px-6 w-full max-w-md mx-auto">
+      {/* Share functionality */}
+      <ShareButton
+        buttonText="Share Mini App"
+        cast={{
+          text: 'Check out this awesome frame @1 @2 @3! 🚀🪐',
+          bestFriends: true,
+          embeds: [`${APP_URL}/share/${context?.user?.fid || ''}`],
+        }}
+        className="w-full"
+      />
+
+      {/* Authentication */}
+      <SignIn />
+
+      {/* Neynar Authentication */}
+      {NeynarAuthButton && <NeynarAuthButton />}
+
+      {/* 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">
+          Send notification result: {notificationState.sendStatus}
+        </div>
+      )}
+      <Button
+        onClick={sendFarcasterNotification}
+        disabled={!notificationDetails}
+        className="w-full"
+      >
+        Send notification
+      </Button>
+
+      {/* Share URL copying */}
+      <Button
+        onClick={copyUserShareUrl}
+        disabled={!context?.user?.fid}
+        className="w-full"
+      >
+        {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">
+          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"
+        >
+          <option value={'light'}>Light</option>
+          <option value={'medium'}>Medium</option>
+          <option value={'heavy'}>Heavy</option>
+          <option value={'soft'}>Soft</option>
+          <option value={'rigid'}>Rigid</option>
+        </select>
+        <Button onClick={triggerHapticFeedback} className="w-full">
+          Trigger Haptic Feedback
+        </Button>
+      </div>
+    </div>
+  );
+}

src/components/ui/tabs/ContextTab.tsx

@@ -0,0 +1,35 @@
+'use client';
+
+import { useMiniApp } from '@neynar/react';
+
+/**
+ * ContextTab component displays the current mini app context in JSON format.
+ *
+ * This component provides a developer-friendly view of the Farcaster mini app context,
+ * including user information, client details, and other contextual data. It's useful
+ * for debugging and understanding what data is available to the mini app.
+ *
+ * The context includes:
+ * - User information (FID, username, display name, profile picture)
+ * - Client information (safe area insets, platform details)
+ * - Mini app configuration and state
+ *
+ * @example
+ * ```tsx
+ * <ContextTab />
+ * ```
+ */
+export function ContextTab() {
+  const { context } = useMiniApp();
+
+  return (
+    <div className="mx-6">
+      <h2 className="text-lg font-semibold mb-2">Context</h2>
+      <div className="p-4 bg-gray-100 dark:bg-gray-800 rounded-lg">
+        <pre className="font-mono text-xs whitespace-pre-wrap break-words w-full">
+          {JSON.stringify(context, null, 2)}
+        </pre>
+      </div>
+    </div>
+  );
+}

src/components/ui/tabs/HomeTab.tsx

@@ -0,0 +1,26 @@
+'use client';
+
+/**
+ * HomeTab component displays the main landing content for the mini app.
+ *
+ * This is the default tab that users see when they first open the mini app.
+ * It provides a simple welcome message and placeholder content that can be
+ * customized for specific use cases.
+ *
+ * @example
+ * ```tsx
+ * <HomeTab />
+ * ```
+ */
+export function HomeTab() {
+  return (
+    <div className="flex items-center justify-center h-[calc(100vh-200px)] px-6">
+      <div className="text-center w-full max-w-md mx-auto">
+        <p className="text-lg mb-2">Put your content here!</p>
+        <p className="text-sm text-gray-500 dark:text-gray-400">
+          Powered by Neynar 🪐
+        </p>
+      </div>
+    </div>
+  );
+}

src/components/ui/tabs/WalletTab.tsx

@@ -0,0 +1,366 @@
+'use client';
+
+import { useCallback, useMemo, useState, useEffect } from 'react';
+import { useMiniApp } from '@neynar/react';
+import { useWallet as useSolanaWallet } from '@solana/wallet-adapter-react';
+import {
+  useAccount,
+  useSendTransaction,
+  useSignTypedData,
+  useWaitForTransactionReceipt,
+  useDisconnect,
+  useConnect,
+  useSwitchChain,
+  useChainId,
+  type Connector,
+} from 'wagmi';
+import { base, degen, mainnet, optimism, unichain } from 'wagmi/chains';
+import { USE_WALLET, APP_NAME } from '../../../lib/constants';
+import { renderError } from '../../../lib/errorUtils';
+import { truncateAddress } from '../../../lib/truncateAddress';
+import { Button } from '../Button';
+import { SendEth } from '../wallet/SendEth';
+import { SendSolana } from '../wallet/SendSolana';
+import { SignEvmMessage } from '../wallet/SignEvmMessage';
+import { SignSolanaMessage } from '../wallet/SignSolanaMessage';
+
+/**
+ * WalletTab component manages wallet-related UI for both EVM and Solana chains.
+ *
+ * This component provides a comprehensive wallet interface that supports:
+ * - EVM wallet connections (Farcaster Frame, Coinbase Wallet, MetaMask)
+ * - Solana wallet integration
+ * - Message signing for both chains
+ * - Transaction sending for both chains
+ * - Chain switching for EVM chains
+ * - Auto-connection in Farcaster clients
+ *
+ * The component automatically detects when running in a Farcaster client
+ * and attempts to auto-connect using the Farcaster Frame connector.
+ *
+ * @example
+ * ```tsx
+ * <WalletTab />
+ * ```
+ */
+
+interface WalletStatusProps {
+  address?: string;
+  chainId?: number;
+}
+
+/**
+ * Displays the current wallet address and chain ID.
+ */
+function WalletStatus({ address, chainId }: WalletStatusProps) {
+  return (
+    <>
+      {address && (
+        <div className="text-xs w-full">
+          Address:{' '}
+          <pre className="inline w-full">{truncateAddress(address)}</pre>
+        </div>
+      )}
+      {chainId && (
+        <div className="text-xs w-full">
+          Chain ID: <pre className="inline w-full">{chainId}</pre>
+        </div>
+      )}
+    </>
+  );
+}
+
+interface ConnectionControlsProps {
+  isConnected: boolean;
+  context: {
+    user?: { fid?: number };
+    client?: unknown;
+  } | null;
+  connect: (args: { connector: Connector }) => void;
+  connectors: readonly Connector[];
+  disconnect: () => void;
+}
+
+/**
+ * Renders wallet connection controls based on connection state and context.
+ */
+function ConnectionControls({
+  isConnected,
+  context,
+  connect,
+  connectors,
+  disconnect,
+}: ConnectionControlsProps) {
+  if (isConnected) {
+    return (
+      <Button onClick={() => disconnect()} className="w-full">
+        Disconnect
+      </Button>
+    );
+  }
+  if (context) {
+    return (
+      <div className="space-y-2 w-full">
+        <Button
+          onClick={() => connect({ connector: connectors[0] })}
+          className="w-full"
+        >
+          Connect (Auto)
+        </Button>
+        <Button
+          onClick={() => {
+            connect({ connector: connectors[0] });
+          }}
+          className="w-full"
+        >
+          Connect Farcaster (Manual)
+        </Button>
+      </div>
+    );
+  }
+  return (
+    <div className="space-y-3 w-full">
+      <Button
+        onClick={() => connect({ connector: connectors[1] })}
+        className="w-full"
+      >
+        Connect Coinbase Wallet
+      </Button>
+      <Button
+        onClick={() => connect({ connector: connectors[2] })}
+        className="w-full"
+      >
+        Connect MetaMask
+      </Button>
+    </div>
+  );
+}
+
+export function WalletTab() {
+  // --- State ---
+  const [evmContractTransactionHash, setEvmContractTransactionHash] = useState<
+    string | null
+  >(null);
+
+  // --- Hooks ---
+  const { context } = useMiniApp();
+  const { address, isConnected } = useAccount();
+  const chainId = useChainId();
+  const solanaWallet = useSolanaWallet();
+  const { publicKey: solanaPublicKey } = solanaWallet;
+
+  // --- Wagmi Hooks ---
+  const {
+    sendTransaction,
+    error: evmTransactionError,
+    isError: isEvmTransactionError,
+    isPending: isEvmTransactionPending,
+  } = useSendTransaction();
+
+  const {
+    isLoading: isEvmTransactionConfirming,
+    isSuccess: isEvmTransactionConfirmed,
+  } = useWaitForTransactionReceipt({
+    hash: evmContractTransactionHash as `0x${string}`,
+  });
+
+  const {
+    signTypedData,
+    error: evmSignTypedDataError,
+    isError: isEvmSignTypedDataError,
+    isPending: isEvmSignTypedDataPending,
+  } = useSignTypedData();
+
+  const { disconnect } = useDisconnect();
+  const { connect, connectors } = useConnect();
+
+  const {
+    switchChain,
+    error: chainSwitchError,
+    isError: isChainSwitchError,
+    isPending: isChainSwitchPending,
+  } = useSwitchChain();
+
+  // --- Effects ---
+  /**
+   * Auto-connect when Farcaster context is available.
+   *
+   * This effect detects when the app is running in a Farcaster client
+   * and automatically attempts to connect using the Farcaster Frame connector.
+   * It includes comprehensive logging for debugging connection issues.
+   */
+  useEffect(() => {
+    // Check if we're in a Farcaster client environment
+    const isInFarcasterClient =
+      typeof window !== 'undefined' &&
+      (window.location.href.includes('warpcast.com') ||
+        window.location.href.includes('farcaster') ||
+        window.ethereum?.isFarcaster ||
+        context?.client);
+
+    if (
+      context?.user?.fid &&
+      !isConnected &&
+      connectors.length > 0 &&
+      isInFarcasterClient
+    ) {
+      // Use the first connector (farcasterFrame) for auto-connection
+      try {
+        connect({ connector: connectors[0] });
+      } catch (error) {
+        console.error('Auto-connection failed:', error);
+      }
+    }
+  }, [context?.user?.fid, isConnected, connectors, connect, context?.client]);
+
+  // --- Computed Values ---
+  /**
+   * Determines the next chain to switch to based on the current chain.
+   * Cycles through: Base → Optimism → Degen → Mainnet → Unichain → Base
+   */
+  const nextChain = useMemo(() => {
+    if (chainId === base.id) {
+      return optimism;
+    } else if (chainId === optimism.id) {
+      return degen;
+    } else if (chainId === degen.id) {
+      return mainnet;
+    } else if (chainId === mainnet.id) {
+      return unichain;
+    } else {
+      return base;
+    }
+  }, [chainId]);
+
+  // --- Handlers ---
+  /**
+   * Handles switching to the next chain in the rotation.
+   * Uses the switchChain function from wagmi to change the active chain.
+   */
+  const handleSwitchChain = useCallback(() => {
+    switchChain({ chainId: nextChain.id });
+  }, [switchChain, nextChain.id]);
+
+  /**
+   * Sends a transaction to call the yoink() function on the Yoink contract.
+   *
+   * This function sends a transaction to a specific contract address with
+   * the encoded function call data for the yoink() function.
+   */
+  const sendEvmContractTransaction = useCallback(() => {
+    sendTransaction(
+      {
+        // call yoink() on Yoink contract
+        to: '0x4bBFD120d9f352A0BEd7a014bd67913a2007a878',
+        data: '0x9846cd9efc000023c0',
+      },
+      {
+        onSuccess: hash => {
+          setEvmContractTransactionHash(hash);
+        },
+      },
+    );
+  }, [sendTransaction]);
+
+  /**
+   * Signs typed data using EIP-712 standard.
+   *
+   * This function creates a typed data structure with the app name, version,
+   * and chain ID, then requests the user to sign it.
+   */
+  const signTyped = useCallback(() => {
+    signTypedData({
+      domain: {
+        name: APP_NAME,
+        version: '1',
+        chainId,
+      },
+      types: {
+        Message: [{ name: 'content', type: 'string' }],
+      },
+      message: {
+        content: `Hello from ${APP_NAME}!`,
+      },
+      primaryType: 'Message',
+    });
+  }, [chainId, signTypedData]);
+
+  // --- Early Return ---
+  if (!USE_WALLET) {
+    return null;
+  }
+
+  // --- Render ---
+  return (
+    <div className="space-y-3 px-6 w-full max-w-md mx-auto">
+      {/* Wallet Information Display */}
+      <WalletStatus address={address} chainId={chainId} />
+
+      {/* Connection Controls */}
+      <ConnectionControls
+        isConnected={isConnected}
+        context={context}
+        connect={connect}
+        connectors={connectors}
+        disconnect={disconnect}
+      />
+
+      {/* EVM Wallet Components */}
+      <SignEvmMessage />
+
+      {isConnected && (
+        <>
+          <SendEth />
+          <Button
+            onClick={sendEvmContractTransaction}
+            disabled={!isConnected || isEvmTransactionPending}
+            isLoading={isEvmTransactionPending}
+            className="w-full"
+          >
+            Send Transaction (contract)
+          </Button>
+          {isEvmTransactionError && renderError(evmTransactionError)}
+          {evmContractTransactionHash && (
+            <div className="text-xs w-full">
+              <div>Hash: {truncateAddress(evmContractTransactionHash)}</div>
+              <div>
+                Status:{' '}
+                {isEvmTransactionConfirming
+                  ? 'Confirming...'
+                  : isEvmTransactionConfirmed
+                    ? 'Confirmed!'
+                    : 'Pending'}
+              </div>
+            </div>
+          )}
+          <Button
+            onClick={signTyped}
+            disabled={!isConnected || isEvmSignTypedDataPending}
+            isLoading={isEvmSignTypedDataPending}
+            className="w-full"
+          >
+            Sign Typed Data
+          </Button>
+          {isEvmSignTypedDataError && renderError(evmSignTypedDataError)}
+          <Button
+            onClick={handleSwitchChain}
+            disabled={isChainSwitchPending}
+            isLoading={isChainSwitchPending}
+            className="w-full"
+          >
+            Switch to {nextChain.name}
+          </Button>
+          {isChainSwitchError && renderError(chainSwitchError)}
+        </>
+      )}
+
+      {/* Solana Wallet Components */}
+      {solanaPublicKey && (
+        <>
+          <SignSolanaMessage signMessage={solanaWallet.signMessage} />
+          <SendSolana />
+        </>
+      )}
+    </div>
+  );
+}

src/components/ui/tabs/index.ts

@@ -0,0 +1,4 @@
+export { HomeTab } from './HomeTab';
+export { ActionsTab } from './ActionsTab';
+export { ContextTab } from './ContextTab';
+export { WalletTab } from './WalletTab';

src/components/ui/wallet/SendEth.tsx

@@ -0,0 +1,108 @@
+'use client';
+
+import { useCallback, useMemo } from 'react';
+import {
+  useAccount,
+  useSendTransaction,
+  useWaitForTransactionReceipt,
+} from 'wagmi';
+import { base } from 'wagmi/chains';
+import { renderError } from '../../../lib/errorUtils';
+import { truncateAddress } from '../../../lib/truncateAddress';
+import { Button } from '../Button';
+
+/**
+ * SendEth component handles sending ETH transactions to protocol guild addresses.
+ *
+ * This component provides a simple interface for users to send small amounts
+ * of ETH to protocol guild addresses. It automatically selects the appropriate
+ * recipient address based on the current chain and displays transaction status.
+ *
+ * Features:
+ * - Chain-specific recipient addresses
+ * - Transaction status tracking
+ * - Error handling and display
+ * - Transaction hash display
+ *
+ * @example
+ * ```tsx
+ * <SendEth />
+ * ```
+ */
+export function SendEth() {
+  // --- Hooks ---
+  const { isConnected, chainId } = useAccount();
+  const {
+    sendTransaction,
+    data: ethTransactionHash,
+    error: ethTransactionError,
+    isError: isEthTransactionError,
+    isPending: isEthTransactionPending,
+  } = useSendTransaction();
+
+  const {
+    isLoading: isEthTransactionConfirming,
+    isSuccess: isEthTransactionConfirmed,
+  } = useWaitForTransactionReceipt({
+    hash: ethTransactionHash,
+  });
+
+  // --- Computed Values ---
+  /**
+   * Determines the recipient address based on the current chain.
+   *
+   * Uses different protocol guild addresses for different chains:
+   * - Base: 0x32e3C7fD24e175701A35c224f2238d18439C7dBC
+   * - Other chains: 0xB3d8d7887693a9852734b4D25e9C0Bb35Ba8a830
+   *
+   * @returns string - The recipient address for the current chain
+   */
+  const protocolGuildRecipientAddress = useMemo(() => {
+    // Protocol guild address
+    return chainId === base.id
+      ? '0x32e3C7fD24e175701A35c224f2238d18439C7dBC'
+      : '0xB3d8d7887693a9852734b4D25e9C0Bb35Ba8a830';
+  }, [chainId]);
+
+  // --- Handlers ---
+  /**
+   * Handles sending the ETH transaction.
+   *
+   * This function sends a small amount of ETH (1 wei) to the protocol guild
+   * address for the current chain. The transaction is sent using the wagmi
+   * sendTransaction hook.
+   */
+  const sendEthTransaction = useCallback(() => {
+    sendTransaction({
+      to: protocolGuildRecipientAddress,
+      value: 1n,
+    });
+  }, [protocolGuildRecipientAddress, sendTransaction]);
+
+  // --- Render ---
+  return (
+    <>
+      <Button
+        onClick={sendEthTransaction}
+        disabled={!isConnected || isEthTransactionPending}
+        isLoading={isEthTransactionPending}
+      >
+        Send Transaction (eth)
+      </Button>
+      {isEthTransactionError && renderError(ethTransactionError)}
+      {ethTransactionHash && (
+        <div className="mt-2 text-xs">
+          <div>Hash: {truncateAddress(ethTransactionHash)}</div>
+          <div>
+            Status:{' '}
+            {isEthTransactionConfirming
+              ? 'Confirming...'
+              : isEthTransactionConfirmed
+                ? 'Confirmed!'
+                : 'Pending'}
+          </div>
+        </div>
+      )}
+    </>
+  );
+}

src/components/ui/wallet/SendSolana.tsx

@@ -0,0 +1,117 @@
+'use client';
+
+import { useCallback, useState } from 'react';
+import {
+  useConnection as useSolanaConnection,
+  useWallet as useSolanaWallet,
+} from '@solana/wallet-adapter-react';
+import { PublicKey, SystemProgram, Transaction } from '@solana/web3.js';
+import { renderError } from '../../../lib/errorUtils';
+import { truncateAddress } from '../../../lib/truncateAddress';
+import { Button } from '../Button';
+
+/**
+ * SendSolana component handles sending SOL transactions on Solana.
+ *
+ * This component provides a simple interface for users to send SOL transactions
+ * using their connected Solana wallet. It includes transaction status tracking
+ * and error handling.
+ *
+ * Features:
+ * - SOL transaction sending
+ * - Transaction status tracking
+ * - Error handling and display
+ * - Loading state management
+ *
+ * Note: This component is a placeholder implementation. In a real application,
+ * you would integrate with a Solana wallet adapter and transaction library
+ * like @solana/web3.js to handle actual transactions.
+ *
+ * @example
+ * ```tsx
+ * <SendSolana />
+ * ```
+ */
+export function SendSolana() {
+  const [solanaTransactionState, setSolanaTransactionState] = useState<
+    | { status: 'none' }
+    | { status: 'pending' }
+    | { status: 'error'; error: Error }
+    | { status: 'success'; signature: string }
+  >({ status: 'none' });
+
+  const { connection: solanaConnection } = useSolanaConnection();
+  const { sendTransaction, publicKey } = useSolanaWallet();
+
+  // This should be replaced but including it from the original demo
+  // https://github.com/farcasterxyz/frames-v2-demo/blob/main/src/components/Demo.tsx#L718
+  const ashoatsPhantomSolanaWallet =
+    'Ao3gLNZAsbrmnusWVqQCPMrcqNi6jdYgu8T6NCoXXQu1';
+
+  /**
+   * Handles sending the Solana transaction
+   */
+  const sendSolanaTransaction = useCallback(async () => {
+    setSolanaTransactionState({ status: 'pending' });
+    try {
+      if (!publicKey) {
+        throw new Error('no Solana publicKey');
+      }
+
+      const { blockhash } = await solanaConnection.getLatestBlockhash();
+      if (!blockhash) {
+        throw new Error('failed to fetch latest Solana blockhash');
+      }
+
+      const fromPubkeyStr = publicKey.toBase58();
+      const toPubkeyStr = ashoatsPhantomSolanaWallet;
+      const transaction = new Transaction();
+      transaction.add(
+        SystemProgram.transfer({
+          fromPubkey: new PublicKey(fromPubkeyStr),
+          toPubkey: new PublicKey(toPubkeyStr),
+          lamports: 0n,
+        }),
+      );
+      transaction.recentBlockhash = blockhash;
+      transaction.feePayer = new PublicKey(fromPubkeyStr);
+
+      const simulation =
+        await solanaConnection.simulateTransaction(transaction);
+      if (simulation.value.err) {
+        // Gather logs and error details for debugging
+        const logs = simulation.value.logs?.join('\n') ?? 'No logs';
+        const errDetail = JSON.stringify(simulation.value.err);
+        throw new Error(`Simulation failed: ${errDetail}\nLogs:\n${logs}`);
+      }
+      const signature = await sendTransaction(transaction, solanaConnection);
+      setSolanaTransactionState({ status: 'success', signature });
+    } catch (e) {
+      if (e instanceof Error) {
+        setSolanaTransactionState({ status: 'error', error: e });
+      } else {
+        setSolanaTransactionState({ status: 'none' });
+      }
+    }
+  }, [sendTransaction, publicKey, solanaConnection]);
+
+  return (
+    <>
+      <Button
+        onClick={sendSolanaTransaction}
+        disabled={solanaTransactionState.status === 'pending'}
+        isLoading={solanaTransactionState.status === 'pending'}
+        className="mb-4"
+      >
+        Send Transaction (sol)
+      </Button>
+      {solanaTransactionState.status === 'error' &&
+        renderError(solanaTransactionState.error)}
+      {solanaTransactionState.status === 'success' && (
+        <div className="mt-2 text-xs">
+          <div>Hash: {truncateAddress(solanaTransactionState.signature)}</div>
+        </div>
+      )}
+    </>
+  );
+}

src/components/ui/wallet/SignEvmMessage.tsx

@@ -0,0 +1,81 @@
+'use client';
+
+import { useCallback } from 'react';
+import { useAccount, useConnect, useSignMessage } from 'wagmi';
+import { base } from 'wagmi/chains';
+import { APP_NAME } from '../../../lib/constants';
+import { renderError } from '../../../lib/errorUtils';
+import { config } from '../../providers/WagmiProvider';
+import { Button } from '../Button';
+
+/**
+ * SignEvmMessage component handles signing messages on EVM-compatible chains.
+ *
+ * This component provides a simple interface for users to sign messages using
+ * their connected EVM wallet. It automatically handles wallet connection if
+ * the user is not already connected, and displays the signature result.
+ *
+ * Features:
+ * - Automatic wallet connection if needed
+ * - Message signing with app name
+ * - Error handling and display
+ * - Signature result display
+ *
+ * @example
+ * ```tsx
+ * <SignEvmMessage />
+ * ```
+ */
+export function SignEvmMessage() {
+  // --- Hooks ---
+  const { isConnected } = useAccount();
+  const { connectAsync } = useConnect();
+  const {
+    signMessage,
+    data: evmMessageSignature,
+    error: evmSignMessageError,
+    isError: isEvmSignMessageError,
+    isPending: isEvmSignMessagePending,
+  } = useSignMessage();
+
+  // --- Handlers ---
+  /**
+   * Handles the message signing process.
+   *
+   * This function first ensures the user is connected to an EVM wallet,
+   * then requests them to sign a message containing the app name.
+   * If the user is not connected, it automatically connects using the
+   * Farcaster Frame connector.
+   *
+   * @returns Promise<void>
+   */
+  const signEvmMessage = useCallback(async () => {
+    if (!isConnected) {
+      await connectAsync({
+        chainId: base.id,
+        connector: config.connectors[0],
+      });
+    }
+
+    signMessage({ message: `Hello from ${APP_NAME}!` });
+  }, [connectAsync, isConnected, signMessage]);
+
+  // --- Render ---
+  return (
+    <>
+      <Button
+        onClick={signEvmMessage}
+        disabled={isEvmSignMessagePending}
+        isLoading={isEvmSignMessagePending}
+      >
+        Sign Message
+      </Button>
+      {isEvmSignMessageError && renderError(evmSignMessageError)}
+      {evmMessageSignature && (
+        <div className="mt-2 text-xs">
+          <div>Signature: {evmMessageSignature}</div>
+        </div>
+      )}
+    </>
+  );
+}

src/components/ui/wallet/SignIn.tsx

@@ -0,0 +1,130 @@
+'use client';
+
+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 QuickAuth.
+ *
+ * This component provides a complete authentication flow for Farcaster users:
+ * - 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 the Farcaster Frame SDK and QuickAuth
+ * to provide seamless authentication within mini apps.
+ *
+ * @example
+ * ```tsx
+ * <SignIn />
+ * ```
+ */
+
+interface AuthState {
+  signingIn: boolean;
+  signingOut: boolean;
+}
+
+export function SignIn() {
+  // --- State ---
+  const [authState, setAuthState] = useState<AuthState>({
+    signingIn: false,
+    signingOut: false,
+  });
+  const [signInFailure, setSignInFailure] = useState<string>();
+
+  // --- Hooks ---
+  const { authenticatedUser, status, signIn, signOut } = useQuickAuth();
+
+  // --- Handlers ---
+  /**
+   * Handles the sign-in process using QuickAuth.
+   *
+   * 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 }));
+      setSignInFailure(undefined);
+
+      const success = await signIn();
+
+      if (!success) {
+        setSignInFailure('Authentication failed');
+      }
+    } catch (e) {
+      if (e instanceof SignInCore.RejectedByUser) {
+        setSignInFailure('Rejected by user');
+        return;
+      }
+      setSignInFailure('Unknown error');
+    } finally {
+      setAuthState(prev => ({ ...prev, signingIn: false }));
+    }
+  }, [signIn]);
+
+  /**
+   * Handles the sign-out process.
+   *
+   * This function clears the QuickAuth session and resets the local state.
+   *
+   * @returns Promise<void>
+   */
+  const handleSignOut = useCallback(async () => {
+    try {
+      setAuthState(prev => ({ ...prev, signingOut: true }));
+      await signOut();
+    } finally {
+      setAuthState(prev => ({ ...prev, signingOut: false }));
+    }
+  }, [signOut]);
+
+  // --- Render ---
+  return (
+    <>
+      {/* Authentication Buttons */}
+      {status !== 'authenticated' && (
+        <Button onClick={handleSignIn} disabled={authState.signingIn}>
+          Sign In with Farcaster
+        </Button>
+      )}
+      {status === 'authenticated' && (
+        <Button onClick={handleSignOut} disabled={authState.signingOut}>
+          Sign out
+        </Button>
+      )}
+
+      {/* Session Information */}
+      {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">
+            Authenticated User
+          </div>
+          <div className="whitespace-pre text-gray-700 dark:text-gray-200">
+            {JSON.stringify(authenticatedUser, null, 2)}
+          </div>
+        </div>
+      )}
+
+      {/* 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">
+            Authentication Error
+          </div>
+          <div className="whitespace-pre text-gray-700 dark:text-gray-200">
+            {signInFailure}
+          </div>
+        </div>
+      )}
+    </>
+  );
+}

src/components/ui/wallet/SignSolanaMessage.tsx

@@ -0,0 +1,87 @@
+'use client';
+
+import { useCallback, useState } from 'react';
+import { renderError } from '../../../lib/errorUtils';
+import { Button } from '../Button';
+
+interface SignSolanaMessageProps {
+  signMessage?: (message: Uint8Array) => Promise<Uint8Array>;
+}
+
+/**
+ * SignSolanaMessage component handles signing messages on Solana.
+ *
+ * This component provides a simple interface for users to sign messages using
+ * their connected Solana wallet. It accepts a signMessage function as a prop
+ * and handles the complete signing flow including error handling.
+ *
+ * Features:
+ * - Message signing with Solana wallet
+ * - Error handling and display
+ * - Signature result display (base64 encoded)
+ * - Loading state management
+ *
+ * @param props - Component props
+ * @param props.signMessage - Function to sign messages with Solana wallet
+ *
+ * @example
+ * ```tsx
+ * <SignSolanaMessage signMessage={solanaWallet.signMessage} />
+ * ```
+ */
+export function SignSolanaMessage({ signMessage }: SignSolanaMessageProps) {
+  // --- State ---
+  const [signature, setSignature] = useState<string | undefined>();
+  const [signError, setSignError] = useState<Error | undefined>();
+  const [signPending, setSignPending] = useState(false);
+
+  // --- Handlers ---
+  /**
+   * Handles the Solana message signing process.
+   *
+   * This function encodes a message as UTF-8 bytes, signs it using the provided
+   * signMessage function, and displays the base64-encoded signature result.
+   * It includes comprehensive error handling and loading state management.
+   *
+   * @returns Promise<void>
+   */
+  const handleSignMessage = useCallback(async () => {
+    setSignPending(true);
+    try {
+      if (!signMessage) {
+        throw new Error('no Solana signMessage');
+      }
+      const input = new TextEncoder().encode('Hello from Solana!');
+      const signatureBytes = await signMessage(input);
+      const signature = btoa(String.fromCharCode(...signatureBytes));
+      setSignature(signature);
+      setSignError(undefined);
+    } catch (e) {
+      if (e instanceof Error) {
+        setSignError(e);
+      }
+    } finally {
+      setSignPending(false);
+    }
+  }, [signMessage]);
+
+  // --- Render ---
+  return (
+    <>
+      <Button
+        onClick={handleSignMessage}
+        disabled={signPending}
+        isLoading={signPending}
+        className="mb-4"
+      >
+        Sign Message
+      </Button>
+      {signError && renderError(signError)}
+      {signature && (
+        <div className="mt-2 text-xs">
+          <div>Signature: {signature}</div>
+        </div>
+      )}
+    </>
+  );
+}

src/components/ui/wallet/index.ts

@@ -0,0 +1,5 @@
+export { SignIn } from './SignIn';
+export { SignEvmMessage } from './SignEvmMessage';
+export { SendEth } from './SendEth';
+export { SignSolanaMessage } from './SignSolanaMessage';
+export { SendSolana } from './SendSolana';

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/hooks/useNeynarUser.ts

@@ -0,0 +1,39 @@
+import { useEffect, useState } from 'react';
+
+export interface NeynarUser {
+  fid: number;
+  score: number;
+}
+
+export function useNeynarUser(context?: { user?: { fid?: number } }) {
+  const [user, setUser] = useState<NeynarUser | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    if (!context?.user?.fid) {
+      setUser(null);
+      setError(null);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    fetch(`/api/users?fids=${context.user.fid}`)
+      .then(response => {
+        if (!response.ok)
+          throw new Error(`HTTP error! status: ${response.status}`);
+        return response.json();
+      })
+      .then(data => {
+        if (data.users?.[0]) {
+          setUser(data.users[0]);
+        } else {
+          setUser(null);
+        }
+      })
+      .catch(err => setError(err.message))
+      .finally(() => setLoading(false));
+  }, [context?.user?.fid]);
+
+  return { user, loading, error };
+}

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,
+  };
+}

src/lib/constants.ts

@@ -1,14 +1,130 @@
-export const APP_URL = process.env.NEXT_PUBLIC_URL!;
-export const APP_NAME = process.env.NEXT_PUBLIC_FRAME_NAME;
-export const APP_DESCRIPTION = process.env.NEXT_PUBLIC_FRAME_DESCRIPTION;
-export const APP_PRIMARY_CATEGORY = process.env.NEXT_PUBLIC_FRAME_PRIMARY_CATEGORY;
-export const APP_TAGS = process.env.NEXT_PUBLIC_FRAME_TAGS?.split(',');
-export const APP_ICON_URL = `${APP_URL}/icon.png`;
-export const APP_OG_IMAGE_URL = `${APP_URL}/api/opengraph-image`;
-export const APP_SPLASH_URL = `${APP_URL}/splash.png`;
-export const APP_SPLASH_BACKGROUND_COLOR = "#f7f7f7";
-export const APP_BUTTON_TEXT = process.env.NEXT_PUBLIC_FRAME_BUTTON_TEXT;
-export const APP_WEBHOOK_URL = process.env.NEYNAR_API_KEY && process.env.NEYNAR_CLIENT_ID 
+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.
+ */
+
+// --- App Configuration ---
+/**
+ * The base URL of the application.
+ * Used for generating absolute URLs for assets and API endpoints.
+ */
+export const APP_URL: string = process.env.NEXT_PUBLIC_URL!;
+
+/**
+ * The name of the mini app as displayed to users.
+ * Used in titles, headers, and app store listings.
+ */
+export const APP_NAME: string = 'Starter Kit';
+
+/**
+ * A brief description of the mini app's functionality.
+ * Used in app store listings and metadata.
+ */
+export const APP_DESCRIPTION: string = 'A demo of the Neynar Starter Kit';
+
+/**
+ * The primary category for the mini app.
+ * Used for app store categorization and discovery.
+ */
+export const APP_PRIMARY_CATEGORY: string = 'developer-tools';
+
+/**
+ * Tags associated with the mini app.
+ * Used for search and discovery in app stores.
+ */
+export const APP_TAGS: string[] = ['neynar', 'starter-kit', 'demo'];
+
+// --- Asset URLs ---
+/**
+ * URL for the app's icon image.
+ * Used in app store listings and UI elements.
+ */
+export const APP_ICON_URL: string = `${APP_URL}/icon.png`;
+
+/**
+ * URL for the app's Open Graph image.
+ * Used for social media sharing and previews.
+ */
+export const APP_OG_IMAGE_URL: string = `${APP_URL}/api/opengraph-image`;
+
+/**
+ * URL for the app's splash screen image.
+ * Displayed during app loading.
+ */
+export const APP_SPLASH_URL: string = `${APP_URL}/splash.png`;
+
+/**
+ * Background color for the splash screen.
+ * Used as fallback when splash image is loading.
+ */
+export const APP_SPLASH_BACKGROUND_COLOR: string = '#f7f7f7';
+
+/**
+ * Account association for the mini app.
+ * Used to associate the mini app with a Farcaster account.
+ * If not provided, the mini app will be unsigned and have limited capabilities.
+ */
+export const APP_ACCOUNT_ASSOCIATION: AccountAssociation | undefined =
+  undefined;
+
+// --- UI Configuration ---
+/**
+ * Text displayed on the main action button.
+ * Used for the primary call-to-action in the mini app.
+ */
+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.
+ */
+export const APP_WEBHOOK_URL: string =
+  process.env.NEYNAR_API_KEY && process.env.NEYNAR_CLIENT_ID
     ? `https://api.neynar.com/f/app/${process.env.NEYNAR_CLIENT_ID}/event`
     : `${APP_URL}/api/webhook`;
-export const USE_WALLET = process.env.NEXT_PUBLIC_USE_WALLET === 'true';
+
+/**
+ * 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.
+ */
+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/errorUtils.tsx

@@ -0,0 +1,66 @@
+import { type ReactElement } from 'react';
+import { BaseError, UserRejectedRequestError } from 'viem';
+
+/**
+ * Renders an error object in a user-friendly format.
+ *
+ * This utility function takes an error object and renders it as a React element
+ * with consistent styling. It handles different types of errors including:
+ * - Error objects with message properties
+ * - Objects with error properties
+ * - String errors
+ * - Unknown error types
+ * - User rejection errors (special handling for wallet rejections)
+ *
+ * The rendered error is displayed in a gray container with monospace font
+ * for better readability of technical error details. User rejections are
+ * displayed with a simpler, more user-friendly message.
+ *
+ * @param error - The error object to render
+ * @returns ReactElement - A styled error display component, or null if no error
+ *
+ * @example
+ * ```tsx
+ * {isError && renderError(error)}
+ * ```
+ */
+export function renderError(error: unknown): ReactElement | null {
+  // Handle null/undefined errors
+  if (!error) return null;
+
+  // Special handling for user rejections in wallet operations
+  if (error instanceof BaseError) {
+    const isUserRejection = error.walk(
+      e => e instanceof UserRejectedRequestError,
+    );
+
+    if (isUserRejection) {
+      return (
+        <div className="mt-2 p-2 text-xs bg-gray-100 dark:bg-gray-800 rounded-lg">
+          <div className="font-semibold text-red-500 mb-1">User Rejection</div>
+          <div>Transaction was rejected by user.</div>
+        </div>
+      );
+    }
+  }
+
+  // Extract error message from different error types
+  let errorMessage: string;
+
+  if (error instanceof Error) {
+    errorMessage = error.message;
+  } else if (typeof error === 'object' && error !== null && 'error' in error) {
+    errorMessage = String(error.error);
+  } else if (typeof error === 'string') {
+    errorMessage = error;
+  } else {
+    errorMessage = 'Unknown error occurred';
+  }
+
+  return (
+    <div className="mt-2 p-2 text-xs overflow-x-scroll bg-gray-100 dark:bg-gray-800 rounded-lg font-mono">
+      <div className="font-semibold text-red-500 mb-1">Error</div>
+      <div className="whitespace-pre-wrap break-words">{errorMessage}</div>
+    </div>
+  );
+}

src/lib/kv.ts

@@ -1,23 +1,25 @@
-import { FrameNotificationDetails } from "@farcaster/frame-sdk";
-import { Redis } from "@upstash/redis";
-import { APP_NAME } from "./constants";
+import { FrameNotificationDetails } from '@farcaster/miniapp-sdk';
+import { Redis } from '@upstash/redis';
+import { APP_NAME } from './constants';
 
 // In-memory fallback storage
 const localStore = new Map<string, FrameNotificationDetails>();
 
 // Use Redis if KV env vars are present, otherwise use in-memory
 const useRedis = process.env.KV_REST_API_URL && process.env.KV_REST_API_TOKEN;
-const redis = useRedis ? new Redis({
-  url: process.env.KV_REST_API_URL!,
-  token: process.env.KV_REST_API_TOKEN!,
-}) : null;
+const redis = useRedis
+  ? new Redis({
+      url: process.env.KV_REST_API_URL!,
+      token: process.env.KV_REST_API_TOKEN!,
+    })
+  : null;
 
 function getUserNotificationDetailsKey(fid: number): string {
   return `${APP_NAME}:user:${fid}`;
 }
 
 export async function getUserNotificationDetails(
-  fid: number
+  fid: number,
 ): Promise<FrameNotificationDetails | null> {
   const key = getUserNotificationDetailsKey(fid);
   if (redis) {
@@ -28,7 +30,7 @@ export async function getUserNotificationDetails(
 
 export async function setUserNotificationDetails(
   fid: number,
-  notificationDetails: FrameNotificationDetails
+  notificationDetails: FrameNotificationDetails,
 ): Promise<void> {
   const key = getUserNotificationDetailsKey(fid);
   if (redis) {
@@ -39,7 +41,7 @@ export async function setUserNotificationDetails(
 }
 
 export async function deleteUserNotificationDetails(
-  fid: number
+  fid: number,
 ): Promise<void> {
   const key = getUserNotificationDetailsKey(fid);
   if (redis) {

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/neynar.ts

@@ -1,4 +1,8 @@
-import { NeynarAPIClient, Configuration, WebhookUserCreated } from '@neynar/nodejs-sdk';
+import {
+  NeynarAPIClient,
+  Configuration,
+  WebhookUserCreated,
+} from '@neynar/nodejs-sdk';
 import { APP_URL } from './constants';
 
 let neynarClient: NeynarAPIClient | null = null;
@@ -31,16 +35,16 @@ export async function getNeynarUser(fid: number): Promise<User | null> {
   }
 }
 
-type SendFrameNotificationResult =
+type SendMiniAppNotificationResult =
   | {
-      state: "error";
+      state: 'error';
       error: unknown;
     }
-  | { state: "no_token" }
-  | { state: "rate_limit" }
-  | { state: "success" };
+  | { state: 'no_token' }
+  | { state: 'rate_limit' }
+  | { state: 'success' };
 
-export async function sendNeynarFrameNotification({
+export async function sendNeynarMiniAppNotification({
   fid,
   title,
   body,
@@ -48,7 +52,7 @@ export async function sendNeynarFrameNotification({
   fid: number;
   title: string;
   body: string;
-}): Promise<SendFrameNotificationResult> {
+}): Promise<SendMiniAppNotificationResult> {
   try {
     const client = getNeynarClient();
     const targetFids = [fid];
@@ -60,17 +64,17 @@ export async function sendNeynarFrameNotification({
 
     const result = await client.publishFrameNotifications({
       targetFids,
-      notification 
+      notification,
     });
 
     if (result.notification_deliveries.length > 0) {
-      return { state: "success" };
+      return { state: 'success' };
     } else if (result.notification_deliveries.length === 0) {
-      return { state: "no_token" };
+      return { state: 'no_token' };
     } else {
-      return { state: "error", error: result || "Unknown error" };
+      return { state: 'error', error: result || 'Unknown error' };
     }
   } catch (error) {
-    return { state: "error", error };
+    return { state: 'error', error };
   }
 }

src/lib/notifs.ts

@@ -1,20 +1,20 @@
 import {
   SendNotificationRequest,
   sendNotificationResponseSchema,
-} from "@farcaster/frame-sdk";
-import { getUserNotificationDetails } from "~/lib/kv";
-import { APP_URL } from "./constants";
+} from '@farcaster/miniapp-sdk';
+import { getUserNotificationDetails } from '~/lib/kv';
+import { APP_URL } from './constants';
 
-type SendFrameNotificationResult =
+type SendMiniAppNotificationResult =
   | {
-      state: "error";
+      state: 'error';
       error: unknown;
     }
-  | { state: "no_token" }
-  | { state: "rate_limit" }
-  | { state: "success" };
+  | { state: 'no_token' }
+  | { state: 'rate_limit' }
+  | { state: 'success' };
 
-export async function sendFrameNotification({
+export async function sendMiniAppNotification({
   fid,
   title,
   body,
@@ -22,16 +22,16 @@ export async function sendFrameNotification({
   fid: number;
   title: string;
   body: string;
-}): Promise<SendFrameNotificationResult> {
+}): Promise<SendMiniAppNotificationResult> {
   const notificationDetails = await getUserNotificationDetails(fid);
   if (!notificationDetails) {
-    return { state: "no_token" };
+    return { state: 'no_token' };
   }
 
   const response = await fetch(notificationDetails.url, {
-    method: "POST",
+    method: 'POST',
     headers: {
-      "Content-Type": "application/json",
+      'Content-Type': 'application/json',
     },
     body: JSON.stringify({
       notificationId: crypto.randomUUID(),
@@ -48,17 +48,17 @@ export async function sendFrameNotification({
     const responseBody = sendNotificationResponseSchema.safeParse(responseJson);
     if (responseBody.success === false) {
       // Malformed response
-      return { state: "error", error: responseBody.error.errors };
+      return { state: 'error', error: responseBody.error.errors };
     }
 
     if (responseBody.data.result.rateLimitedTokens.length) {
       // Rate limited
-      return { state: "rate_limit" };
+      return { state: 'rate_limit' };
     }
 
-    return { state: "success" };
+    return { state: 'success' };
   } else {
     // Error response
-    return { state: "error", error: responseJson };
+    return { state: 'error', error: responseJson };
   }
 }

src/lib/truncateAddress.ts

@@ -1,4 +1,4 @@
 export const truncateAddress = (address: string) => {
-  if (!address) return "";
+  if (!address) return '';
   return `${address.slice(0, 14)}...${address.slice(-12)}`;
 };

src/lib/utils.ts

@@ -1,56 +1,33 @@
+import { type Manifest } from '@farcaster/miniapp-node';
 import { type ClassValue, clsx } from 'clsx';
 import { twMerge } from 'tailwind-merge';
-import { mnemonicToAccount } from 'viem/accounts';
-import { APP_BUTTON_TEXT, APP_DESCRIPTION, APP_ICON_URL, APP_NAME, APP_OG_IMAGE_URL, APP_PRIMARY_CATEGORY, APP_SPLASH_BACKGROUND_COLOR, APP_TAGS, APP_URL, APP_WEBHOOK_URL } from './constants';
-import { APP_SPLASH_URL } from './constants';
-
-interface FrameMetadata {
-  version: string;
-  name: string;
-  iconUrl: string;
-  homeUrl: string;
-  imageUrl?: string;
-  buttonTitle?: string;
-  splashImageUrl?: string;
-  splashBackgroundColor?: string;
-  webhookUrl?: string;
-  description?: string;
-  primaryCategory?: string;
-  tags?: string[];
-};
-
-interface FrameManifest {
-  accountAssociation?: {
-    header: string;
-    payload: string;
-    signature: string;
-  };
-  frame: FrameMetadata;
-}
+import {
+  APP_BUTTON_TEXT,
+  APP_DESCRIPTION,
+  APP_ICON_URL,
+  APP_NAME,
+  APP_OG_IMAGE_URL,
+  APP_PRIMARY_CATEGORY,
+  APP_SPLASH_BACKGROUND_COLOR,
+  APP_SPLASH_URL,
+  APP_TAGS,
+  APP_URL,
+  APP_WEBHOOK_URL,
+  APP_ACCOUNT_ASSOCIATION,
+} from './constants';
 
 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 getFrameEmbedMetadata(ogImageUrl?: string) {
+export function getMiniAppEmbedMetadata(ogImageUrl?: string) {
   return {
-    version: "next",
+    version: 'next',
     imageUrl: ogImageUrl ?? APP_OG_IMAGE_URL,
     button: {
       title: APP_BUTTON_TEXT,
       action: {
-        type: "launch_frame",
+        type: 'launch_frame',
         name: APP_NAME,
         url: APP_URL,
         splashImageUrl: APP_SPLASH_URL,
@@ -64,70 +41,16 @@ export function getFrameEmbedMetadata(ogImageUrl?: string) {
   };
 }
 
-export async function getFarcasterMetadata(): Promise<FrameManifest> {
-  // First check for FRAME_METADATA in .env and use that if it exists
-  if (process.env.FRAME_METADATA) {
-    try {
-      const metadata = JSON.parse(process.env.FRAME_METADATA);
-      console.log('Using pre-signed frame metadata from environment');
-      return metadata;
-    } catch (error) {
-      console.warn('Failed to parse FRAME_METADATA from environment:', error);
-    }
-  }
-
-  if (!APP_URL) {
-    throw new Error('NEXT_PUBLIC_URL not configured');
-  }
-
-  // Get the domain from the URL (without https:// prefix)
-  const domain = new URL(APP_URL).hostname;
-  console.log('Using domain for manifest:', domain);
-
-  const secretEnvVars = getSecretEnvVars();
-  if (!secretEnvVars) {
-    console.warn('No seed phrase or FID found in environment variables -- generating unsigned metadata');
-  }
-
-  let accountAssociation;
-  if (secretEnvVars) {
-    // Generate account from seed phrase
-    const account = mnemonicToAccount(secretEnvVars.seedPhrase);
-    const custodyAddress = account.address;
-
-    const header = {
-      fid: parseInt(secretEnvVars.fid),
-      type: 'custody',
-      key: custodyAddress,
-    };
-    const encodedHeader = Buffer.from(JSON.stringify(header), 'utf-8').toString('base64');
-
-    const payload = {
-      domain
-    };
-    const encodedPayload = Buffer.from(JSON.stringify(payload), 'utf-8').toString('base64url');
-
-    const signature = await account.signMessage({ 
-      message: `${encodedHeader}.${encodedPayload}`
-    });
-    const encodedSignature = Buffer.from(signature, 'utf-8').toString('base64url');
-
-    accountAssociation = {
-      header: encodedHeader,
-      payload: encodedPayload,
-      signature: encodedSignature
-    };
-  }
-
+export async function getFarcasterDomainManifest(): Promise<Manifest> {
   return {
-    accountAssociation,
-    frame: {
-      version: "1",
-      name: APP_NAME ?? "Frames v2 Demo",
+    accountAssociation: APP_ACCOUNT_ASSOCIATION,
+    miniapp: {
+      version: '1',
+      name: APP_NAME ?? 'Neynar Starter Kit',
       iconUrl: APP_ICON_URL,
       homeUrl: APP_URL,
       imageUrl: APP_OG_IMAGE_URL,
-      buttonTitle: APP_BUTTON_TEXT ?? "Launch Frame",
+      buttonTitle: APP_BUTTON_TEXT ?? 'Launch Mini App',
       splashImageUrl: APP_SPLASH_URL,
       splashBackgroundColor: APP_SPLASH_BACKGROUND_COLOR,
       webhookUrl: APP_WEBHOOK_URL,

tailwind.config.ts

@@ -1,24 +0,0 @@
-import type { Config } from "tailwindcss";
-
-export default {
-    darkMode: ["class"],
-    content: [
-    "./src/pages/**/*.{js,ts,jsx,tsx,mdx}",
-    "./src/components/**/*.{js,ts,jsx,tsx,mdx}",
-    "./src/app/**/*.{js,ts,jsx,tsx,mdx}",
-  ],
-  theme: {
-  	extend: {
-  		colors: {
-  			background: 'var(--background)',
-  			foreground: 'var(--foreground)'
-  		},
-  		borderRadius: {
-  			lg: 'var(--radius)',
-  			md: 'calc(var(--radius) - 2px)',
-  			sm: 'calc(var(--radius) - 4px)'
-  		}
-  	}
-  },
-  plugins: [require("tailwindcss-animate")],
-} satisfies Config;