solanapolis 1.0.0

package/src/lib/sound-engine.ts

@@ -0,0 +1,464 @@
+/**
+ * Procedural sound engine for Solanapolis.
+ *
+ * All sounds are synthesized in real-time using the Web Audio API.
+ * No external audio files required.
+ */
+
+// ─── Singleton AudioContext ──────────────────────────────────
+
+let _ctx: AudioContext | null = null;
+let _master: GainNode | null = null;
+let _initialized = false;
+
+function getCtx(): AudioContext {
+  if (!_ctx) {
+    _ctx = new AudioContext();
+    _master = _ctx.createGain();
+    _master.gain.value = 0.3; // global volume
+    _master.connect(_ctx.destination);
+  }
+  return _ctx;
+}
+
+function getMaster(): GainNode {
+  getCtx();
+  return _master!;
+}
+
+/**
+ * Must be called from a user gesture (click/keydown) to unlock AudioContext.
+ */
+export function initAudio(): void {
+  if (_initialized) return;
+  const ctx = getCtx();
+  if (ctx.state === "suspended") {
+    ctx.resume();
+  }
+  _initialized = true;
+}
+
+// ─── Utility: White Noise Buffer ─────────────────────────────
+
+function createNoiseBuffer(duration = 2): AudioBuffer {
+  const ctx = getCtx();
+  const sr = ctx.sampleRate;
+  const len = sr * duration;
+  const buf = ctx.createBuffer(1, len, sr);
+  const data = buf.getChannelData(0);
+  for (let i = 0; i < len; i++) {
+    data[i] = Math.random() * 2 - 1;
+  }
+  return buf;
+}
+
+let _noiseBuf: AudioBuffer | null = null;
+function getNoiseBuffer(): AudioBuffer {
+  if (!_noiseBuf) _noiseBuf = createNoiseBuffer();
+  return _noiseBuf;
+}
+
+// ─── Car Engine ──────────────────────────────────────────────
+// Low-frequency oscillators + distortion for engine rumble
+
+export class CarEngine {
+  private osc1: OscillatorNode | null = null;
+  private osc2: OscillatorNode | null = null;
+  private gain: GainNode | null = null;
+  private filter: BiquadFilterNode | null = null;
+  private running = false;
+
+  start(): void {
+    if (this.running) return;
+    const ctx = getCtx();
+
+    this.gain = ctx.createGain();
+    this.gain.gain.value = 0.08;
+
+    this.filter = ctx.createBiquadFilter();
+    this.filter.type = "lowpass";
+    this.filter.frequency.value = 200;
+    this.filter.Q.value = 3;
+
+    // Primary engine tone
+    this.osc1 = ctx.createOscillator();
+    this.osc1.type = "sawtooth";
+    this.osc1.frequency.value = 55; // A1 — idle rumble
+
+    // Harmonic
+    this.osc2 = ctx.createOscillator();
+    this.osc2.type = "square";
+    this.osc2.frequency.value = 110;
+
+    const osc2Gain = ctx.createGain();
+    osc2Gain.gain.value = 0.3;
+
+    this.osc1.connect(this.filter);
+    this.osc2.connect(osc2Gain).connect(this.filter);
+    this.filter.connect(this.gain).connect(getMaster());
+
+    this.osc1.start();
+    this.osc2.start();
+    this.running = true;
+  }
+
+  /** Set throttle 0–1 to modulate pitch and volume */
+  setThrottle(t: number): void {
+    if (!this.running) return;
+    const throttle = Math.max(0, Math.min(1, t));
+    // Pitch: idle 55Hz → max 180Hz
+    this.osc1!.frequency.value = 55 + throttle * 125;
+    this.osc2!.frequency.value = 110 + throttle * 250;
+    // Volume: idle 0.05 → max 0.15
+    this.gain!.gain.value = 0.05 + throttle * 0.1;
+    // Filter opens with throttle
+    this.filter!.frequency.value = 200 + throttle * 600;
+  }
+
+  stop(): void {
+    if (!this.running) return;
+    try {
+      this.osc1?.stop();
+      this.osc2?.stop();
+    } catch { /* already stopped */ }
+    this.gain?.disconnect();
+    this.running = false;
+  }
+}
+
+// ─── Plane Engine ────────────────────────────────────────────
+// Higher pitch buzz + filtered noise for propeller wind
+
+export class PlaneEngine {
+  private osc: OscillatorNode | null = null;
+  private noiseSrc: AudioBufferSourceNode | null = null;
+  private gain: GainNode | null = null;
+  private noiseGain: GainNode | null = null;
+  private filter: BiquadFilterNode | null = null;
+  private running = false;
+
+  start(): void {
+    if (this.running) return;
+    const ctx = getCtx();
+
+    this.gain = ctx.createGain();
+    this.gain.gain.value = 0.06;
+
+    this.filter = ctx.createBiquadFilter();
+    this.filter.type = "bandpass";
+    this.filter.frequency.value = 400;
+    this.filter.Q.value = 1.5;
+
+    // Propeller tone
+    this.osc = ctx.createOscillator();
+    this.osc.type = "sawtooth";
+    this.osc.frequency.value = 120;
+
+    // Wind noise
+    this.noiseSrc = ctx.createBufferSource();
+    this.noiseSrc.buffer = getNoiseBuffer();
+    this.noiseSrc.loop = true;
+
+    this.noiseGain = ctx.createGain();
+    this.noiseGain.gain.value = 0.03;
+
+    const noiseFilter = ctx.createBiquadFilter();
+    noiseFilter.type = "bandpass";
+    noiseFilter.frequency.value = 800;
+    noiseFilter.Q.value = 0.5;
+
+    this.osc.connect(this.filter).connect(this.gain).connect(getMaster());
+    this.noiseSrc.connect(noiseFilter).connect(this.noiseGain).connect(getMaster());
+
+    this.osc.start();
+    this.noiseSrc.start();
+    this.running = true;
+  }
+
+  /** Set throttle 0–1 */
+  setThrottle(t: number): void {
+    if (!this.running) return;
+    const throttle = Math.max(0, Math.min(1, t));
+    this.osc!.frequency.value = 120 + throttle * 200;
+    this.gain!.gain.value = 0.04 + throttle * 0.08;
+    this.noiseGain!.gain.value = 0.02 + throttle * 0.06;
+    this.filter!.frequency.value = 400 + throttle * 800;
+  }
+
+  stop(): void {
+    if (!this.running) return;
+    try {
+      this.osc?.stop();
+      this.noiseSrc?.stop();
+    } catch { /* already stopped */ }
+    this.gain?.disconnect();
+    this.noiseGain?.disconnect();
+    this.running = false;
+  }
+}
+
+// ─── Gunshot / Projectile Fire ───────────────────────────────
+// Short burst of noise + pitched-down oscillator
+
+export function playGunshot(): void {
+  if (!_initialized) return;
+  const ctx = getCtx();
+  const now = ctx.currentTime;
+
+  // Noise burst
+  const noise = ctx.createBufferSource();
+  noise.buffer = getNoiseBuffer();
+  const noiseGain = ctx.createGain();
+  noiseGain.gain.setValueAtTime(0.12, now);
+  noiseGain.gain.exponentialRampToValueAtTime(0.001, now + 0.08);
+
+  const noiseFilter = ctx.createBiquadFilter();
+  noiseFilter.type = "highpass";
+  noiseFilter.frequency.value = 1500;
+
+  noise.connect(noiseFilter).connect(noiseGain).connect(getMaster());
+  noise.start(now);
+  noise.stop(now + 0.1);
+
+  // Thud tone
+  const osc = ctx.createOscillator();
+  osc.type = "sine";
+  osc.frequency.setValueAtTime(400, now);
+  osc.frequency.exponentialRampToValueAtTime(60, now + 0.06);
+
+  const oscGain = ctx.createGain();
+  oscGain.gain.setValueAtTime(0.15, now);
+  oscGain.gain.exponentialRampToValueAtTime(0.001, now + 0.1);
+
+  osc.connect(oscGain).connect(getMaster());
+  osc.start(now);
+  osc.stop(now + 0.12);
+}
+
+// ─── Hit / Explosion ─────────────────────────────────────────
+
+export function playExplosion(): void {
+  if (!_initialized) return;
+  const ctx = getCtx();
+  const now = ctx.currentTime;
+
+  // Explosion rumble — low freq noise
+  const noise = ctx.createBufferSource();
+  noise.buffer = getNoiseBuffer();
+  const noiseGain = ctx.createGain();
+  noiseGain.gain.setValueAtTime(0.2, now);
+  noiseGain.gain.exponentialRampToValueAtTime(0.001, now + 0.4);
+
+  const filter = ctx.createBiquadFilter();
+  filter.type = "lowpass";
+  filter.frequency.setValueAtTime(800, now);
+  filter.frequency.exponentialRampToValueAtTime(100, now + 0.3);
+
+  noise.connect(filter).connect(noiseGain).connect(getMaster());
+  noise.start(now);
+  noise.stop(now + 0.5);
+
+  // Impact thud
+  const osc = ctx.createOscillator();
+  osc.type = "sine";
+  osc.frequency.setValueAtTime(200, now);
+  osc.frequency.exponentialRampToValueAtTime(30, now + 0.15);
+
+  const oscGain = ctx.createGain();
+  oscGain.gain.setValueAtTime(0.2, now);
+  oscGain.gain.exponentialRampToValueAtTime(0.001, now + 0.2);
+
+  osc.connect(oscGain).connect(getMaster());
+  osc.start(now);
+  osc.stop(now + 0.25);
+}
+
+// ─── Ocean Ambient ───────────────────────────────────────────
+// Looping filtered noise that fades in/out
+
+export class OceanAmbient {
+  private src: AudioBufferSourceNode | null = null;
+  private gain: GainNode | null = null;
+  private running = false;
+
+  start(): void {
+    if (this.running) return;
+    const ctx = getCtx();
+
+    this.src = ctx.createBufferSource();
+    this.src.buffer = getNoiseBuffer();
+    this.src.loop = true;
+
+    const filter = ctx.createBiquadFilter();
+    filter.type = "lowpass";
+    filter.frequency.value = 600;
+    filter.Q.value = 0.5;
+
+    // Slow LFO to modulate gain (wave surging)
+    const lfo = ctx.createOscillator();
+    lfo.type = "sine";
+    lfo.frequency.value = 0.15;
+    const lfoGain = ctx.createGain();
+    lfoGain.gain.value = 0.01;
+    lfo.connect(lfoGain);
+
+    this.gain = ctx.createGain();
+    this.gain.gain.value = 0.04;
+    lfoGain.connect(this.gain.gain);
+
+    this.src.connect(filter).connect(this.gain).connect(getMaster());
+    this.src.start();
+    lfo.start();
+    this.running = true;
+  }
+
+  stop(): void {
+    if (!this.running) return;
+    try { this.src?.stop(); } catch { /* */ }
+    this.gain?.disconnect();
+    this.running = false;
+  }
+}
+
+// ─── Seagull Call ─────────────────────────────────────────────
+// Random high-pitched oscillator squeaks
+
+let _lastSeagullTime = 0;
+
+export function maybePlaySeagull(): void {
+  if (!_initialized) return;
+  const now = performance.now();
+  // At most one call every 3–8 seconds
+  if (now - _lastSeagullTime < 3000 + Math.random() * 5000) return;
+  _lastSeagullTime = now;
+
+  const ctx = getCtx();
+  const t = ctx.currentTime;
+
+  const duration = 0.15 + Math.random() * 0.2;
+  const pitch = 1800 + Math.random() * 1200;
+
+  const osc = ctx.createOscillator();
+  osc.type = "sine";
+  osc.frequency.setValueAtTime(pitch, t);
+  osc.frequency.linearRampToValueAtTime(pitch * 0.7, t + duration);
+
+  const gain = ctx.createGain();
+  gain.gain.setValueAtTime(0, t);
+  gain.gain.linearRampToValueAtTime(0.03, t + 0.02);
+  gain.gain.linearRampToValueAtTime(0, t + duration);
+
+  osc.connect(gain).connect(getMaster());
+  osc.start(t);
+  osc.stop(t + duration + 0.01);
+
+  // Second chirp after a short pause
+  if (Math.random() > 0.4) {
+    const t2 = t + duration + 0.05;
+    const dur2 = 0.1 + Math.random() * 0.15;
+    const osc2 = ctx.createOscillator();
+    osc2.type = "sine";
+    osc2.frequency.setValueAtTime(pitch * 1.1, t2);
+    osc2.frequency.linearRampToValueAtTime(pitch * 0.6, t2 + dur2);
+
+    const g2 = ctx.createGain();
+    g2.gain.setValueAtTime(0, t2);
+    g2.gain.linearRampToValueAtTime(0.025, t2 + 0.015);
+    g2.gain.linearRampToValueAtTime(0, t2 + dur2);
+
+    osc2.connect(g2).connect(getMaster());
+    osc2.start(t2);
+    osc2.stop(t2 + dur2 + 0.01);
+  }
+}
+
+// ─── Boat Horn ───────────────────────────────────────────────
+// Deep foghorn-like tone
+
+export function playBoatHorn(): void {
+  if (!_initialized) return;
+  const ctx = getCtx();
+  const now = ctx.currentTime;
+
+  const osc = ctx.createOscillator();
+  osc.type = "sawtooth";
+  osc.frequency.value = 110;
+
+  const filter = ctx.createBiquadFilter();
+  filter.type = "lowpass";
+  filter.frequency.value = 300;
+  filter.Q.value = 2;
+
+  const gain = ctx.createGain();
+  gain.gain.setValueAtTime(0, now);
+  gain.gain.linearRampToValueAtTime(0.08, now + 0.2);
+  gain.gain.setValueAtTime(0.08, now + 0.8);
+  gain.gain.linearRampToValueAtTime(0, now + 1.2);
+
+  osc.connect(filter).connect(gain).connect(getMaster());
+  osc.start(now);
+  osc.stop(now + 1.3);
+}
+
+// ─── UI Click ────────────────────────────────────────────────
+
+export function playClick(): void {
+  if (!_initialized) return;
+  const ctx = getCtx();
+  const now = ctx.currentTime;
+
+  const osc = ctx.createOscillator();
+  osc.type = "sine";
+  osc.frequency.value = 800;
+
+  const gain = ctx.createGain();
+  gain.gain.setValueAtTime(0.06, now);
+  gain.gain.exponentialRampToValueAtTime(0.001, now + 0.04);
+
+  osc.connect(gain).connect(getMaster());
+  osc.start(now);
+  osc.stop(now + 0.05);
+}
+
+// ─── Score / Hit Confirm ─────────────────────────────────────
+
+export function playScoreChime(): void {
+  if (!_initialized) return;
+  const ctx = getCtx();
+  const now = ctx.currentTime;
+
+  // Rising two-note chime
+  const osc1 = ctx.createOscillator();
+  osc1.type = "sine";
+  osc1.frequency.value = 880; // A5
+
+  const g1 = ctx.createGain();
+  g1.gain.setValueAtTime(0.08, now);
+  g1.gain.exponentialRampToValueAtTime(0.001, now + 0.15);
+
+  osc1.connect(g1).connect(getMaster());
+  osc1.start(now);
+  osc1.stop(now + 0.2);
+
+  const osc2 = ctx.createOscillator();
+  osc2.type = "sine";
+  osc2.frequency.value = 1320; // E6
+
+  const g2 = ctx.createGain();
+  g2.gain.setValueAtTime(0.06, now + 0.08);
+  g2.gain.exponentialRampToValueAtTime(0.001, now + 0.25);
+
+  osc2.connect(g2).connect(getMaster());
+  osc2.start(now + 0.08);
+  osc2.stop(now + 0.3);
+}
+
+// ─── Volume Control ──────────────────────────────────────────
+
+export function setMasterVolume(v: number): void {
+  getMaster().gain.value = Math.max(0, Math.min(1, v));
+}
+
+export function getMasterVolume(): number {
+  return getMaster().gain.value;
+}

package/src/lib/supabase-admin.ts

@@ -0,0 +1,9 @@
+import { createClient } from "@supabase/supabase-js";
+
+export function createAdminClient() {
+  return createClient(
+    process.env.NEXT_PUBLIC_SUPABASE_URL!,
+    process.env.SUPABASE_SERVICE_ROLE_KEY!,
+    { auth: { autoRefreshToken: false, persistSession: false } }
+  );
+}

package/src/lib/supabase.ts

@@ -0,0 +1,8 @@
+import { createBrowserClient } from "@supabase/ssr";
+
+export function createClient() {
+  return createBrowserClient(
+    process.env.NEXT_PUBLIC_SUPABASE_URL!,
+    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!
+  );
+}

package/src/lib/swap-events.ts

@@ -0,0 +1,70 @@
+"use client";
+
+import { useEffect, useRef } from "react";
+import { PlacedWallet } from "@/types/wallet";
+
+export interface SwapEvent {
+  walletAddress: string;
+  signature: string;
+  tokenIn: string | null;
+  tokenOut: string | null;
+  amountSol: number | null;
+}
+
+const MAX_QUEUE = 60;
+const POLL_INTERVAL = 4000; // fetch a batch every 4 seconds
+const BATCH_SIZE = 3; // swaps per batch
+
+/**
+ * Periodically fetch random existing swap events from the DB
+ * to keep cars spawning without needing live webhook data.
+ */
+export function useSwapEvents(wallets: PlacedWallet[]): React.MutableRefObject<SwapEvent[]> {
+  const queueRef = useRef<SwapEvent[]>([]);
+
+  useEffect(() => {
+    if (wallets.length === 0) return;
+
+    let cancelled = false;
+
+    async function fetchRandomSwaps() {
+      try {
+        const { createClient } = await import("@/lib/supabase");
+        const supabase = createClient();
+
+        // Fetch random existing swap events
+        const { data } = await supabase
+          .rpc("get_random_swaps", { n: BATCH_SIZE });
+
+        if (cancelled || !data) return;
+
+        for (const row of data) {
+          const event: SwapEvent = {
+            walletAddress: row.wallet_address,
+            signature: `${row.signature}-${Date.now()}`, // unique key so car system treats as new
+            tokenIn: row.token_in ?? null,
+            tokenOut: row.token_out ?? null,
+            amountSol: row.amount_sol != null ? Number(row.amount_sol) : null,
+          };
+          const q = queueRef.current;
+          q.push(event);
+          if (q.length > MAX_QUEUE) q.splice(0, q.length - MAX_QUEUE);
+        }
+      } catch {
+        // Silently ignore — cars just won't spawn this cycle
+      }
+    }
+
+    // Initial fetch after short delay
+    const initialTimeout = setTimeout(fetchRandomSwaps, 2000);
+    const interval = setInterval(fetchRandomSwaps, POLL_INTERVAL);
+
+    return () => {
+      cancelled = true;
+      clearTimeout(initialTimeout);
+      clearInterval(interval);
+    };
+  }, [wallets]);
+
+  return queueRef;
+}

package/src/middleware.ts

@@ -0,0 +1,37 @@
+import { createServerClient } from "@supabase/ssr";
+import { NextResponse, type NextRequest } from "next/server";
+
+export async function middleware(request: NextRequest) {
+  let response = NextResponse.next({ request });
+
+  const supabase = createServerClient(
+    process.env.NEXT_PUBLIC_SUPABASE_URL!,
+    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
+    {
+      cookies: {
+        getAll() {
+          return request.cookies.getAll();
+        },
+        setAll(cookiesToSet) {
+          cookiesToSet.forEach(({ name, value }) =>
+            request.cookies.set(name, value)
+          );
+          response = NextResponse.next({ request });
+          cookiesToSet.forEach(({ name, value, options }) =>
+            response.cookies.set(name, value, options)
+          );
+        },
+      },
+    }
+  );
+
+  await supabase.auth.getUser();
+
+  return response;
+}
+
+export const config = {
+  matcher: [
+    "/((?!_next/static|_next/image|favicon.ico|.*\\.(?:svg|png|jpg|jpeg|gif|webp)$).*)",
+  ],
+};

package/src/types/phantom.d.ts

@@ -0,0 +1,16 @@
+interface PhantomSolana {
+  isPhantom: boolean;
+  connect(): Promise<{ publicKey: { toString(): string; toBytes(): Uint8Array } }>;
+  disconnect(): Promise<void>;
+  signMessage(
+    message: Uint8Array,
+    encoding: string
+  ): Promise<{ signature: Uint8Array }>;
+  on(event: string, callback: () => void): void;
+}
+
+interface Window {
+  phantom?: {
+    solana?: PhantomSolana;
+  };
+}

package/src/types/wallet.ts

@@ -0,0 +1,20 @@
+export interface WalletBuilding {
+  address: string;
+  txnCount: number;
+  walletAgeDays: number;
+  volumeTraded: number; // in SOL
+  feesPaid: number; // in SOL
+  ingestionStatus?: "queued" | "processing" | "complete" | "failed";
+  uniqueTokensSwapped?: number;
+  latestBlocktime?: number; // unix seconds
+  identityName?: string | null;
+  identityType?: string | null;
+  identityCategory?: string | null;
+  xUsername?: string | null;
+}
+
+export interface PlacedWallet extends WalletBuilding {
+  blockRow: number;
+  blockCol: number;
+  localSlot: number;
+}

package/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts",
+    "**/*.mts"
+  ],
+  "exclude": ["node_modules", "cesium-flight-simulator-main", "persistent-text-streaming-main", "ai-town-main", "convex"]
+}