solanapolis 1.0.0

package/src/context/AuthContext.tsx

@@ -0,0 +1,230 @@
+"use client";
+
+import {
+  createContext,
+  useContext,
+  useEffect,
+  useState,
+  useCallback,
+  type ReactNode,
+} from "react";
+import { createClient } from "@/lib/supabase";
+import type { User } from "@supabase/supabase-js";
+import { usePhantom, useModal } from "@phantom/react-sdk";
+
+interface Profile {
+  id: string;
+  wallet_address: string | null;
+  x_username: string | null;
+  x_avatar_url: string | null;
+}
+
+interface PhantomSdkAddress {
+  type?: string;
+  address?: string;
+}
+
+interface PhantomSdkUserLike {
+  solana?: {
+    address?: string;
+  };
+  addresses?: PhantomSdkAddress[];
+}
+
+interface AuthContextValue {
+  user: User | null;
+  profile: Profile | null;
+  loading: boolean;
+  connectPhantom: () => Promise<void>;
+  connectX: () => Promise<void>;
+  linkWallet: () => Promise<void>;
+  signOut: () => Promise<void>;
+  phantomAddress: string | null;
+  phantomConnected: boolean;
+  openPhantomModal: () => void;
+  closePhantomModal: () => void;
+}
+
+const AuthContext = createContext<AuthContextValue | null>(null);
+
+export function AuthProvider({ children }: { children: ReactNode }) {
+  const [supabase] = useState(() => createClient());
+  const [user, setUser] = useState<User | null>(null);
+  const [profile, setProfile] = useState<Profile | null>(null);
+  const [loading, setLoading] = useState(true);
+
+  const { isConnected: phantomConnected, user: phantomUser } = usePhantom();
+  const { open: openPhantomModal, close: closePhantomModal } = useModal();
+  const phantomSdkUser = phantomUser as PhantomSdkUserLike | null;
+  const phantomAddress: string | null =
+    phantomSdkUser?.solana?.address ??
+    phantomSdkUser?.addresses?.find((a) => a.type === "solana")?.address ??
+    null;
+
+  const fetchProfile = useCallback(
+    async (userId: string) => {
+      const { data } = await supabase
+        .from("profiles")
+        .select("*")
+        .eq("id", userId)
+        .single();
+      setProfile(data);
+    },
+    [supabase]
+  );
+
+  useEffect(() => {
+    supabase.auth.getUser().then(({ data: { user } }) => {
+      setUser(user ?? null);
+      if (user) fetchProfile(user.id);
+      setLoading(false);
+    });
+
+    const {
+      data: { subscription },
+    } = supabase.auth.onAuthStateChange((_event, session) => {
+      const newUser = session?.user ?? null;
+      setUser(newUser);
+      if (newUser) {
+        fetchProfile(newUser.id);
+      } else {
+        setProfile(null);
+      }
+    });
+
+    return () => subscription.unsubscribe();
+  }, [supabase, fetchProfile]);
+
+  const connectPhantom = useCallback(async () => {
+    const provider = window.phantom?.solana;
+    if (!provider?.isPhantom) {
+      window.open("https://phantom.app/", "_blank");
+      return;
+    }
+
+    const { publicKey } = await provider.connect();
+    const walletAddress = publicKey.toString();
+
+    const timestamp = Date.now();
+    const message = `Sign in to Solanapolis\nWallet: ${walletAddress}\nTimestamp: ${timestamp}`;
+    const encodedMessage = new TextEncoder().encode(message);
+
+    const { signature } = await provider.signMessage(encodedMessage, "utf8");
+
+    // Encode as base64 for transport
+    const signatureBase64 = btoa(String.fromCharCode(...signature));
+    const publicKeyBase64 = btoa(String.fromCharCode(...publicKey.toBytes()));
+
+    const res = await fetch("/api/auth/phantom", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        walletAddress,
+        publicKey: publicKeyBase64,
+        signature: signatureBase64,
+        message,
+        timestamp,
+      }),
+    });
+
+    if (!res.ok) {
+      const err = await res.json();
+      throw new Error(err.error ?? "Phantom auth failed");
+    }
+
+    const { token_hash } = await res.json();
+
+    const { error } = await supabase.auth.verifyOtp({
+      token_hash,
+      type: "magiclink",
+    });
+
+    if (error) throw error;
+  }, [supabase]);
+
+  const connectX = useCallback(async () => {
+    // If already signed in (e.g. via Phantom), stash wallet so the callback
+    // can transfer it to the X-authenticated user, then sign out first.
+    if (user && profile?.wallet_address) {
+      document.cookie = `pendingWalletLink=${profile.wallet_address}; path=/; max-age=300; samesite=lax`;
+      await supabase.auth.signOut();
+    }
+
+    // Always use signInWithOAuth — avoids identity_already_exists errors
+    const { error } = await supabase.auth.signInWithOAuth({
+      provider: "x",
+      options: {
+        redirectTo: `${window.location.origin}/api/auth/callback`,
+      },
+    });
+    if (error) throw error;
+  }, [supabase, user, profile]);
+
+  const linkWallet = useCallback(async () => {
+    if (!user) return;
+
+    const provider = window.phantom?.solana;
+    if (!provider?.isPhantom) {
+      window.open("https://phantom.app/", "_blank");
+      return;
+    }
+
+    const { publicKey } = await provider.connect();
+    const walletAddress = publicKey.toString();
+
+    const timestamp = Date.now();
+    const message = `Link wallet to Solanapolis\nWallet: ${walletAddress}\nTimestamp: ${timestamp}`;
+    const encodedMessage = new TextEncoder().encode(message);
+
+    const { signature } = await provider.signMessage(encodedMessage, "utf8");
+
+    const signatureBase64 = btoa(String.fromCharCode(...signature));
+    const publicKeyBase64 = btoa(String.fromCharCode(...publicKey.toBytes()));
+
+    const res = await fetch("/api/auth/link-wallet", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        walletAddress,
+        publicKey: publicKeyBase64,
+        signature: signatureBase64,
+        message,
+        timestamp,
+      }),
+    });
+
+    if (!res.ok) {
+      const err = await res.json();
+      throw new Error(err.error ?? "Failed to link wallet");
+    }
+
+    // Refresh profile to pick up the new wallet_address
+    await fetchProfile(user.id);
+  }, [user, fetchProfile]);
+
+  const signOut = useCallback(async () => {
+    // Disconnect Phantom if connected
+    try {
+      await window.phantom?.solana?.disconnect();
+    } catch {
+      // ignore
+    }
+    await supabase.auth.signOut();
+    setUser(null);
+    setProfile(null);
+  }, [supabase]);
+
+  return (
+    <AuthContext.Provider
+      value={{ user, profile, loading, connectPhantom, connectX, linkWallet, signOut, phantomAddress, phantomConnected, openPhantomModal, closePhantomModal }}
+    >
+      {children}
+    </AuthContext.Provider>
+  );
+}
+
+export function useAuth() {
+  const ctx = useContext(AuthContext);
+  if (!ctx) throw new Error("useAuth must be used within AuthProvider");
+  return ctx;
+}

package/src/lib/bot-detection.ts

@@ -0,0 +1,125 @@
+const HELIUS_API_KEY = process.env.HELIUS_API_KEY!;
+const HELIUS_RPC_URL = `https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}`;
+
+const BOT_DETECTION_TXS_PER_MINUTE = 20;
+const MIN_TXS_FOR_BOT_CHECK = 100;
+
+interface HeliusSignatureEntry {
+  signature: string;
+  blockTime: number | null;
+}
+
+async function fetchTransactionsFromHelius(
+  address: string,
+  limit: number,
+  sortOrder: "asc" | "desc",
+): Promise<HeliusSignatureEntry[]> {
+  const res = await fetch(HELIUS_RPC_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "getTransactionsForAddress",
+      params: [
+        address,
+        {
+          sortOrder,
+          limit,
+          transactionDetails: "full",
+          encoding: "json",
+          maxSupportedTransactionVersion: 0,
+          filters: {
+            status: "succeeded",
+            tokenAccounts: "balanceChanged",
+          },
+        },
+      ],
+    }),
+  });
+
+  if (!res.ok) {
+    throw new Error(`Helius RPC error: ${res.status} ${res.statusText}`);
+  }
+
+  const json = await res.json();
+  if (json.error) {
+    throw new Error(`Helius RPC error: ${json.error.message}`);
+  }
+
+  return json.result?.data ?? [];
+}
+
+interface DensityResult {
+  isBot: boolean;
+  txsPerMinute: number;
+  label: string;
+}
+
+function checkBotDensity(
+  transactions: HeliusSignatureEntry[],
+  label: string,
+): DensityResult {
+  // Filter out transactions with no blockTime
+  const valid = transactions.filter((tx) => tx.blockTime != null && tx.blockTime > 0);
+  if (valid.length < 2) {
+    return { isBot: false, txsPerMinute: 0, label };
+  }
+
+  // Sort by blockTime ascending
+  valid.sort((a, b) => a.blockTime! - b.blockTime!);
+
+  const oldest = valid[0].blockTime!;
+  const newest = valid[valid.length - 1].blockTime!;
+  const timeSpanMinutes = (newest - oldest) / 60;
+
+  // All txns in the same block/second — treat as bot
+  if (timeSpanMinutes === 0) {
+    return { isBot: true, txsPerMinute: Infinity, label };
+  }
+
+  const txsPerMinute = valid.length / timeSpanMinutes;
+  return {
+    isBot: txsPerMinute >= BOT_DETECTION_TXS_PER_MINUTE,
+    txsPerMinute,
+    label,
+  };
+}
+
+export interface BotDetectionResult {
+  isBot: boolean;
+  reason?: string;
+}
+
+export async function detectBotActivity(
+  address: string,
+): Promise<BotDetectionResult> {
+  // Fetch oldest 100 transactions first
+  const oldest = await fetchTransactionsFromHelius(address, MIN_TXS_FOR_BOT_CHECK, "asc");
+
+  // If fewer than 100 total transactions, skip bot check
+  if (oldest.length < MIN_TXS_FOR_BOT_CHECK) {
+    return { isBot: false };
+  }
+
+  const oldestCheck = checkBotDensity(oldest, "oldest");
+  if (oldestCheck.isBot) {
+    return {
+      isBot: true,
+      reason: `High tx density in oldest transactions: ${oldestCheck.txsPerMinute.toFixed(1)} txns/min`,
+    };
+  }
+
+  // Fetch newest 100 transactions
+  const newest = await fetchTransactionsFromHelius(address, MIN_TXS_FOR_BOT_CHECK, "desc");
+
+  const newestCheck = checkBotDensity(newest, "newest");
+  if (newestCheck.isBot) {
+    return {
+      isBot: true,
+      reason: `High tx density in newest transactions: ${newestCheck.txsPerMinute.toFixed(1)} txns/min`,
+    };
+  }
+
+  return { isBot: false };
+}

package/src/lib/building-math.ts

@@ -0,0 +1,136 @@
+import { WalletBuilding, PlacedWallet } from "@/types/wallet";
+import { CELL_SIZE, ROAD_WIDTH, BLOCK_SIZE, BLOCK_STRIDE, BLOCKS_PER_ROW, GRID_WORLD } from "./city-constants";
+import { SkyscraperType } from "./skyscraper-types";
+import { getBlockZone } from "./city-zoning";
+
+// --- Height: txn count → floors (1–150) → world height ---
+
+const FLOOR_HEIGHT = 0.3; // world units per floor
+
+export function floors(txns: number): number {
+  // Map 10 → 500k into 0..1 in log-space, then apply x^2 easing
+  // so low-txn wallets stay short and only 100k+ get truly tall.
+  txns = Math.max(10, Math.min(txns, 500_000));
+  const x = (Math.log10(txns) - 1) / (Math.log10(500_000) - 1); // 0..1 over [10, 500k]
+  const eased = x * x; // quadratic — spreads out mid-to-high range
+  return Math.round(1 + eased * 149);
+}
+
+// --- Width: volume → 0.6–3.0 world units (scaled to fit cell grid) ---
+// Spec maps 4–20 abstract units; we remap to 0.6–3.0 to fit CELL_SIZE=4
+
+const WIDTH_WORLD_MIN = 0.6;
+const WIDTH_WORLD_MAX = 3.0;
+
+function buildingWidth(volume: number, maxVolume: number): number {
+  if (maxVolume <= 0) return WIDTH_WORLD_MIN;
+  const x = Math.log10(volume + 1) / Math.log10(maxVolume + 1);
+  const abstract = 4 + 16 * Math.sqrt(x); // 4–20
+  // Remap 4–20 → 0.6–3.0
+  const t = (abstract - 4) / 16;
+  return WIDTH_WORLD_MIN + t * (WIDTH_WORLD_MAX - WIDTH_WORLD_MIN);
+}
+
+// Depth = width (square footprint per spec)
+
+// We need maxVolume across all wallets for the width formula.
+// Compute it once and cache.
+let cachedMaxVolume = 0;
+
+export function setMaxVolume(wallets: WalletBuilding[]) {
+  cachedMaxVolume = 0;
+  for (const w of wallets) {
+    if (w.volumeTraded > cachedMaxVolume) cachedMaxVolume = w.volumeTraded;
+  }
+}
+
+export function getBuildingDimensions(wallet: WalletBuilding) {
+  const height = floors(wallet.txnCount) * FLOOR_HEIGHT;
+  const width = buildingWidth(wallet.volumeTraded, cachedMaxVolume);
+  const depth = width; // square footprint
+  return { height, width, depth };
+}
+
+// Color based on height — realistic urban palette
+// Short buildings: warm sandstone/brick tones
+// Mid-rise: concrete/tan
+// Tall buildings: cool slate gray / steel blue
+const COLOR_HEIGHT_MAX = 150 * FLOOR_HEIGHT; // 45 units (150 floors)
+
+/** World-space position for a placed wallet (matches InstancedBuildings) */
+export function getWalletWorldPosition(
+  w: PlacedWallet,
+  dims: { width: number; depth: number; height: number },
+): [number, number, number] {
+  const offset = -GRID_WORLD / 2 + BLOCK_SIZE / 2 + ROAD_WIDTH / 2;
+  const blockOriginX = offset + w.blockCol * BLOCK_STRIDE - BLOCK_SIZE / 2;
+  const blockOriginZ = offset + w.blockRow * BLOCK_STRIDE - BLOCK_SIZE / 2;
+  const localRow = Math.floor(w.localSlot / 4);
+  const localCol = w.localSlot % 4;
+  return [
+    blockOriginX + localCol * CELL_SIZE + dims.width / 2 + 0.5,
+    dims.height / 2,
+    blockOriginZ + localRow * CELL_SIZE + dims.depth / 2 + 0.5,
+  ];
+}
+
+// --- Window math ---
+
+export function getWindowCols(buildingWidth: number): number {
+  return Math.max(2, Math.min(7, Math.round(buildingWidth * 2.5)));
+}
+
+export function getWindowFillRatio(uniqueTokensSwapped: number): number {
+  if (uniqueTokensSwapped <= 0) return 0;
+  return Math.max(0.02, Math.min(1.0, uniqueTokensSwapped / (uniqueTokensSwapped + 500)));
+}
+
+export function getLitRatio(latestBlocktime: number | null | undefined): number {
+  if (latestBlocktime == null) return 0.05;
+  const nowSeconds = Date.now() / 1000;
+  const ageDays = (nowSeconds - latestBlocktime) / 86400;
+  return Math.min(0.45, Math.max(0.05, 0.45 * Math.exp(-ageDays / 14)));
+}
+
+export function getInstanceSeed(address: string): number {
+  let hash = 0;
+  for (let i = 0; i < address.length; i++) {
+    hash = (hash * 31 + address.charCodeAt(i)) | 0;
+  }
+  return Math.abs(hash % 10007) / 10007;
+}
+
+export function getWindowRows(floorCount: number): number {
+  return Math.min(floorCount, 35);
+}
+
+// --- Skyscraper type assignment ---
+
+/**
+ * Deterministically assign a skyscraper type to a downtown wallet.
+ * Non-downtown wallets always get "box".
+ */
+export function getSkyscraperType(wallet: PlacedWallet): SkyscraperType {
+  const zone = getBlockZone(wallet.blockRow, wallet.blockCol, BLOCKS_PER_ROW);
+  if (zone.zone !== "downtown") return "box";
+
+  const seed = getInstanceSeed(wallet.address);
+  if (seed < 0.40) return "box";
+  if (seed < 0.55) return "setback";
+  if (seed < 0.70) return "twin";
+  if (seed < 0.85) return "cantilever";
+  return "spire";
+}
+
+export function getBuildingColor(height: number): string {
+  const t = Math.min(1, height / COLOR_HEIGHT_MAX);
+
+  // Short (t≈0): lighter concrete   rgb(100, 98, 110)
+  // Mid  (t≈0.5): mid slate        rgb(82, 82, 105)
+  // Tall (t≈1): near ground tone   rgb(65, 68, 95)
+  // Ground is #4a4a65 = rgb(74, 74, 101)
+  const r = Math.floor(100 - t * 35);
+  const g = Math.floor(98 - t * 30);
+  const b = Math.floor(110 - t * 15);
+  return `rgb(${r},${g},${b})`;
+}