solanapolis 1.0.0

package/src/app/api/treasury/route.ts

@@ -0,0 +1,83 @@
+import { NextResponse } from "next/server";
+
+/**
+ * Treasury balance API — fetches SOL balance of the reward treasury wallet.
+ * Primary: Helius RPC getBalance (reliable, fast)
+ * Also fetches SOL price from Helius Wallet API for USD display
+ */
+
+const TREASURY_ADDRESS = "76QQqndM87DBQAeAnRnjdMSiVBgBNrm55HMa88MRVc7p";
+const REWARD_PER_PARCEL = 0.069420;
+
+export async function GET() {
+  try {
+    const apiKey = process.env.HELIUS_API_KEY;
+    const rpcUrl = process.env.HELIUS_RPC_URL || `https://mainnet.helius-rpc.com/?api-key=${apiKey}`;
+
+    // Primary: getBalance via RPC (most reliable)
+    const balRes = await fetch(rpcUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: "treasury-bal",
+        method: "getBalance",
+        params: [TREASURY_ADDRESS],
+      }),
+    });
+
+    const balData = await balRes.json();
+    const lamports = balData?.result?.value ?? 0;
+    const sol = lamports / 1_000_000_000;
+
+    // Try to get SOL price from Helius Wallet API for USD display
+    let solPrice: number | null = null;
+    let solUsdValue: number | null = null;
+
+    if (apiKey) {
+      try {
+        const walletRes = await fetch(
+          `https://api.helius.xyz/v1/wallet/${TREASURY_ADDRESS}/balances?api-key=${apiKey}&showNative=true`,
+          { signal: AbortSignal.timeout(5000) },
+        );
+        if (walletRes.ok) {
+          const wData = await walletRes.json();
+          const solEntry = wData.balances?.find(
+            (b: { mint: string }) => b.mint === "So11111111111111111111111111111111111111112",
+          );
+          if (solEntry) {
+            solPrice = solEntry.pricePerToken ?? null;
+            solUsdValue = solEntry.usdValue ?? null;
+          }
+        }
+      } catch {
+        // Wallet API failed — still have balance from RPC, just no USD price
+      }
+    }
+
+    // Calculate how many 0.069420 SOL parcels can still be funded
+    const TX_FEE = 0.000005;
+    const parcelsRemaining = Math.floor(sol / (REWARD_PER_PARCEL + TX_FEE));
+
+    return NextResponse.json({
+      address: TREASURY_ADDRESS,
+      balanceSOL: Math.round(sol * 1_000_000) / 1_000_000,
+      balanceLamports: lamports,
+      solUsdValue,
+      solPrice,
+      parcelsRemaining,
+      rewardPerParcel: REWARD_PER_PARCEL,
+      source: "helius-rpc",
+    }, {
+      headers: { "Cache-Control": "public, max-age=15" },
+    });
+  } catch (err) {
+    console.error("Treasury balance error:", err);
+    return NextResponse.json({
+      address: TREASURY_ADDRESS,
+      balanceSOL: 0,
+      parcelsRemaining: 0,
+      error: "Failed to fetch balance",
+    }, { status: 500 });
+  }
+}

package/src/app/api/wallet/[address]/balances/route.ts

@@ -0,0 +1,124 @@
+import { NextRequest, NextResponse } from "next/server";
+
+const HELIUS_API_KEY = process.env.HELIUS_API_KEY!;
+const HELIUS_RPC_URL = `https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}`;
+
+interface TokenInfo {
+  mint: string;
+  symbol?: string;
+  name?: string;
+  description?: string;
+  image?: string;
+  amount: number;
+  decimals: number;
+  uiAmount: number;
+  price?: number;
+  value?: number;
+  supply?: number;
+  marketCap?: number;
+}
+
+export async function GET(
+  _req: NextRequest,
+  { params }: { params: Promise<{ address: string }> },
+) {
+  const { address } = await params;
+
+  if (!/^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(address)) {
+    return NextResponse.json(
+      { error: "Invalid Solana address" },
+      { status: 400 },
+    );
+  }
+
+  try {
+    // Single DAS call to get all fungible tokens with metadata, prices, and native balance
+    const dasRes = await fetch(HELIUS_RPC_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "getAssetsByOwner",
+        params: {
+          ownerAddress: address,
+          page: 1,
+          limit: 100,
+          displayOptions: {
+            showFungible: true,
+            showNativeBalance: true,
+          },
+        },
+      }),
+    });
+
+    const dasJson = await dasRes.json();
+    if (dasJson.error) {
+      throw new Error(`DAS error: ${dasJson.error.message}`);
+    }
+
+    const result = dasJson.result;
+    const solBalance = (result.nativeBalance?.lamports ?? 0) / 1e9;
+
+    // Filter to fungible tokens with balance > 0
+    const tokens: TokenInfo[] = [];
+    for (const item of result.items ?? []) {
+      const isFungible =
+        item.interface === "FungibleToken" || item.interface === "FungibleAsset";
+      if (!isFungible) continue;
+
+      const ti = item.token_info;
+      if (!ti || !ti.balance || ti.balance <= 0) continue;
+
+      const decimals = ti.decimals ?? 0;
+      const uiAmount = ti.balance / Math.pow(10, decimals);
+      const price = ti.price_info?.price_per_token ?? undefined;
+      const supply = ti.supply != null
+        ? ti.supply / Math.pow(10, decimals)
+        : undefined;
+
+      tokens.push({
+        mint: item.id,
+        symbol:
+          item.content?.metadata?.symbol ||
+          ti.symbol ||
+          undefined,
+        name: item.content?.metadata?.name || undefined,
+        description: item.content?.metadata?.description || undefined,
+        image:
+          item.content?.links?.image ||
+          item.content?.files?.[0]?.cdn_uri ||
+          item.content?.files?.[0]?.uri ||
+          undefined,
+        amount: ti.balance,
+        decimals,
+        uiAmount,
+        price,
+        value: price != null ? uiAmount * price : undefined,
+        supply,
+        marketCap:
+          price != null && supply != null ? supply * price : undefined,
+      });
+    }
+
+    // Sort by value (USD) descending, fall back to uiAmount
+    tokens.sort((a, b) => (b.value ?? 0) - (a.value ?? 0) || b.uiAmount - a.uiAmount);
+
+    return NextResponse.json(
+      {
+        solBalance,
+        tokenCount: tokens.length,
+        tokens: tokens.slice(0, 20),
+      },
+      {
+        headers: { "Cache-Control": "public, max-age=60" },
+      },
+    );
+  } catch (err) {
+    console.error("Balance fetch error:", err);
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : "Unknown error" },
+      { status: 500 },
+    );
+  }
+}

package/src/app/api/wallet/[address]/identity/route.ts

@@ -0,0 +1,32 @@
+import { NextResponse } from "next/server";
+import { createAdminClient } from "@/lib/supabase-admin";
+
+export async function GET(
+  _req: Request,
+  { params }: { params: Promise<{ address: string }> },
+) {
+  const { address } = await params;
+  const supabase = createAdminClient();
+
+  // Read-only — return cached identity, no writes
+  const { data: row } = await supabase
+    .from("wallets")
+    .select("identity_name, identity_type, identity_category")
+    .eq("address", address)
+    .single();
+
+  if (row?.identity_name) {
+    return NextResponse.json({
+      identity: {
+        name: row.identity_name,
+        type: row.identity_type ?? "unknown",
+        category: row.identity_category ?? "",
+      },
+    });
+  }
+
+  return NextResponse.json(
+    { identity: null },
+    { headers: { "Cache-Control": "public, s-maxage=86400, stale-while-revalidate=86400" } },
+  );
+}

package/src/app/api/wallet/[address]/route.ts

@@ -0,0 +1,216 @@
+import { NextRequest, NextResponse } from "next/server";
+import { WalletStats, getWalletIdentity, getWalletFunding } from "@/lib/helius";
+import { createAdminClient } from "@/lib/supabase-admin";
+
+/**
+ * GET /api/wallet/[address]
+ *
+ * If the wallet exists in the DB, return its stats.
+ * If NOT, auto-ingest it using Helius APIs (Enhanced Transactions + Identity),
+ * place it in the city grid, and return the result.
+ */
+export async function GET(
+  _req: NextRequest,
+  { params }: { params: Promise<{ address: string }> },
+) {
+  const { address } = await params;
+
+  if (!/^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(address)) {
+    return NextResponse.json(
+      { error: "Invalid Solana address" },
+      { status: 400 },
+    );
+  }
+
+  try {
+    const supabase = createAdminClient();
+
+    // Check if wallet already exists
+    const { data: existing, error: selectError } = await supabase
+      .from("wallets")
+      .select(
+        "address, txn_count, volume_traded_sol, fees_paid_sol, wallet_age_days, first_tx_at, ingestion_status, unique_tokens_swapped, latest_tx_at",
+      )
+      .eq("address", address)
+      .single();
+
+    if (selectError && selectError.code !== "PGRST116") {
+      throw new Error(`DB error: ${selectError.message}`);
+    }
+
+    // Wallet already in the city — return its stats
+    if (existing) {
+      const stats: WalletStats = {
+        address: existing.address,
+        txnCount: existing.txn_count,
+        walletAgeDays: existing.wallet_age_days,
+        volumeTraded: existing.volume_traded_sol,
+        feesPaid: existing.fees_paid_sol,
+        firstTxTimestamp: existing.first_tx_at
+          ? Math.floor(new Date(existing.first_tx_at).getTime() / 1000)
+          : null,
+        ingestionStatus: existing.ingestion_status,
+        uniqueTokensSwapped: existing.unique_tokens_swapped,
+        latestBlocktime: existing.latest_tx_at
+          ? Math.floor(new Date(existing.latest_tx_at).getTime() / 1000)
+          : null,
+      };
+      return NextResponse.json(stats);
+    }
+
+    // --- NEW WALLET: Auto-ingest using Helius APIs ---
+
+    // Check 1,000 wallet cap
+    const { count: walletCount } = await supabase
+      .from("wallets")
+      .select("*", { count: "exact", head: true });
+
+    if ((walletCount ?? 0) >= 1000) {
+      return NextResponse.json(
+        { error: "City is full! Only 1,000 spots available." },
+        { status: 429 },
+      );
+    }
+
+    const rpcUrl = process.env.HELIUS_RPC_URL;
+    if (!rpcUrl) {
+      return NextResponse.json(
+        { error: "RPC not configured" },
+        { status: 500 },
+      );
+    }
+
+    // Fetch transaction signatures to get real stats
+    const [sigRes, identityResult, fundingResult] = await Promise.all([
+      fetch(rpcUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: "sigs",
+          method: "getSignaturesForAddress",
+          params: [address, { limit: 1000 }],
+        }),
+      }),
+      getWalletIdentity(address).catch(() => null),
+      getWalletFunding(address).catch(() => null),
+    ]);
+
+    const sigData = await sigRes.json();
+    const sigs = sigData.result ?? [];
+
+    if (sigs.length === 0) {
+      return NextResponse.json(
+        { error: "No transactions found for this wallet" },
+        { status: 404 },
+      );
+    }
+
+    // Calculate basic stats from signatures
+    const txnCount = sigs.length;
+    const now = Date.now() / 1000;
+
+    // Oldest and newest blocktimes
+    const blocktimes = sigs
+      .map((s: { blockTime: number | null }) => s.blockTime)
+      .filter((bt: number | null): bt is number => bt !== null);
+
+    const oldestBlocktime = blocktimes.length > 0 ? Math.min(...blocktimes) : null;
+    const newestBlocktime = blocktimes.length > 0 ? Math.max(...blocktimes) : null;
+
+    // Wallet age from funding info or oldest tx
+    let firstTxAt: Date | null = null;
+    let walletAgeDays = 0;
+
+    if (fundingResult?.timestamp) {
+      firstTxAt = new Date(fundingResult.timestamp * 1000);
+      walletAgeDays = Math.floor((now - fundingResult.timestamp) / 86400);
+    } else if (oldestBlocktime) {
+      firstTxAt = new Date(oldestBlocktime * 1000);
+      walletAgeDays = Math.floor((now - oldestBlocktime) / 86400);
+    }
+
+    const latestTxAt = newestBlocktime ? new Date(newestBlocktime * 1000) : null;
+
+    // Estimate volume from SOL balance check
+    const balRes = await fetch(rpcUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: "bal",
+        method: "getBalance",
+        params: [address],
+      }),
+    });
+    const balData = await balRes.json();
+    const solBalance = (balData.result?.value ?? 0) / 1e9;
+
+    // Rough volume estimate based on tx count and balance
+    const volumeEstimate = solBalance + txnCount * 0.05;
+    const feesEstimate = txnCount * 0.000005;
+
+    // Get token accounts count as unique tokens estimate
+    const tokenRes = await fetch(rpcUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: "tokens",
+        method: "getTokenAccountsByOwner",
+        params: [
+          address,
+          { programId: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" },
+          { encoding: "jsonParsed" },
+        ],
+      }),
+    });
+    const tokenData = await tokenRes.json();
+    const uniqueTokens = tokenData.result?.value?.length ?? 0;
+
+    // Insert the wallet
+    const { error: insertError } = await supabase.from("wallets").upsert({
+      address,
+      txn_count: txnCount,
+      volume_traded_sol: Number(volumeEstimate.toFixed(4)),
+      fees_paid_sol: Number(feesEstimate.toFixed(6)),
+      wallet_age_days: walletAgeDays,
+      first_tx_at: firstTxAt?.toISOString() ?? null,
+      latest_tx_at: latestTxAt?.toISOString() ?? null,
+      ingestion_status: "complete",
+      unique_tokens_swapped: uniqueTokens,
+      identity_name: identityResult?.name ?? null,
+      identity_type: identityResult?.type ?? null,
+      identity_category: identityResult?.category ?? null,
+      updated_at: new Date().toISOString(),
+    }, { onConflict: "address" });
+
+    if (insertError) {
+      throw new Error(`Insert error: ${insertError.message}`);
+    }
+
+    // Assign a city position
+    await supabase.rpc("assign_city_position", { p_address: address });
+
+    // Return the new wallet stats
+    const stats: WalletStats = {
+      address,
+      txnCount,
+      walletAgeDays,
+      volumeTraded: Number(volumeEstimate.toFixed(4)),
+      feesPaid: Number(feesEstimate.toFixed(6)),
+      firstTxTimestamp: oldestBlocktime ?? (fundingResult?.timestamp ?? null),
+      ingestionStatus: "complete",
+      uniqueTokensSwapped: uniqueTokens,
+      latestBlocktime: newestBlocktime,
+    };
+
+    return NextResponse.json({ ...stats, isNew: true });
+  } catch (err) {
+    console.error("Wallet fetch error:", err);
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : "Unknown error" },
+      { status: 500 },
+    );
+  }
+}

package/src/app/api/wallet/[address]/traded-tokens/route.ts

@@ -0,0 +1,41 @@
+import { NextRequest, NextResponse } from "next/server";
+import { createAdminClient } from "@/lib/supabase-admin";
+
+export async function GET(
+  _req: NextRequest,
+  { params }: { params: Promise<{ address: string }> },
+) {
+  const { address } = await params;
+
+  if (!/^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(address)) {
+    return NextResponse.json(
+      { error: "Invalid Solana address" },
+      { status: 400 },
+    );
+  }
+
+  try {
+    const supabase = createAdminClient();
+
+    const { data: wallet, error } = await supabase
+      .from("wallets")
+      .select("traded_token_mints")
+      .eq("address", address)
+      .single();
+
+    if (error && error.code !== "PGRST116") {
+      throw new Error(`DB error: ${error.message}`);
+    }
+
+    return NextResponse.json(
+      { mints: wallet?.traded_token_mints ?? [] },
+      { headers: { "Cache-Control": "public, max-age=300" } },
+    );
+  } catch (err) {
+    console.error("Traded tokens fetch error:", err);
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : "Unknown error" },
+      { status: 500 },
+    );
+  }
+}

package/src/app/api/wallets/route.ts

@@ -0,0 +1,68 @@
+import { NextResponse } from "next/server";
+import { createAdminClient } from "@/lib/supabase-admin";
+
+export async function GET() {
+  try {
+    const supabase = createAdminClient();
+
+    // Self-heal: assign positions to any unplaced complete wallets
+    await supabase.rpc("repair_unplaced_wallets");
+
+    const [walletsResult, profilesResult] = await Promise.all([
+      supabase
+        .from("wallets")
+        .select(
+          "address, txn_count, volume_traded_sol, fees_paid_sol, wallet_age_days, block_row, block_col, local_slot, unique_tokens_swapped, latest_tx_at, identity_name, identity_type, identity_category"
+        )
+        .not("block_row", "is", null)
+        .limit(11000),
+      supabase
+        .from("profiles")
+        .select("wallet_address, x_username")
+        .not("x_username", "is", null),
+    ]);
+
+    if (walletsResult.error) {
+      throw new Error(`DB error: ${walletsResult.error.message}`);
+    }
+
+    const profileMap = new Map<string, string>();
+    for (const p of profilesResult.data ?? []) {
+      if (p.wallet_address && p.x_username) {
+        profileMap.set(p.wallet_address, p.x_username);
+      }
+    }
+
+    const wallets = (walletsResult.data ?? []).map((row) => ({
+      address: row.address,
+      txnCount: row.txn_count,
+      walletAgeDays: row.wallet_age_days,
+      volumeTraded: row.volume_traded_sol,
+      feesPaid: row.fees_paid_sol,
+      blockRow: row.block_row,
+      blockCol: row.block_col,
+      localSlot: row.local_slot,
+      uniqueTokensSwapped: row.unique_tokens_swapped,
+      latestBlocktime: row.latest_tx_at ? Math.floor(new Date(row.latest_tx_at).getTime() / 1000) : null,
+      identityName: row.identity_name ?? null,
+      identityType: row.identity_type ?? null,
+      identityCategory: row.identity_category ?? null,
+      xUsername: profileMap.get(row.address) ?? null,
+    }));
+
+    return NextResponse.json(
+      { wallets, totalPlaced: wallets.length },
+      {
+        headers: {
+          "Cache-Control": "public, max-age=30",
+        },
+      }
+    );
+  } catch (err) {
+    console.error("Wallets fetch error:", err);
+    return NextResponse.json(
+      { error: err instanceof Error ? err.message : "Unknown error" },
+      { status: 500 }
+    );
+  }
+}

package/src/app/api/webhooks/helius/route.ts

@@ -0,0 +1,76 @@
+import { NextRequest, NextResponse } from "next/server";
+import { createAdminClient } from "@/lib/supabase-admin";
+
+/**
+ * Helius Enhanced Webhook handler.
+ * Receives SWAP events, stores them, and broadcasts to Supabase Realtime.
+ */
+export async function POST(req: NextRequest) {
+  // Verify auth header
+  const authHeader = req.headers.get("authorization");
+  const expected = `Bearer ${process.env.HELIUS_WEBHOOK_SECRET}`;
+  if (authHeader !== expected) {
+    return NextResponse.json({ error: "unauthorized" }, { status: 401 });
+  }
+
+  try {
+    const events = await req.json();
+    if (!Array.isArray(events) || events.length === 0) {
+      return NextResponse.json({ received: 0 });
+    }
+
+    const supabase = createAdminClient();
+    let stored = 0;
+
+    for (const event of events) {
+      // Only process SWAP type
+      if (event.type !== "SWAP") continue;
+
+      const swap = event.events?.swap;
+      if (!swap) continue;
+
+      const feePayer = event.feePayer;
+      const signature = event.signature;
+      const timestamp = event.timestamp
+        ? new Date(event.timestamp * 1000).toISOString()
+        : new Date().toISOString();
+
+      // Extract token in/out from swap event
+      const tokenIn =
+        swap.tokenInputs?.[0]?.mint ??
+        (swap.nativeInput?.account ? "So11111111111111111111111111111111" : null);
+      const tokenOut =
+        swap.tokenOutputs?.[0]?.mint ??
+        (swap.nativeOutput?.account ? "So11111111111111111111111111111111" : null);
+
+      // Compute SOL amount
+      let amountSol: number | null = null;
+      if (swap.nativeInput?.amount) {
+        amountSol = Number(swap.nativeInput.amount) / 1e9;
+      } else if (swap.nativeOutput?.amount) {
+        amountSol = Number(swap.nativeOutput.amount) / 1e9;
+      }
+
+
+      // Insert swap event
+      const { error } = await supabase.from("swap_events").insert({
+        wallet_address: feePayer,
+        signature,
+        token_in: tokenIn,
+        token_out: tokenOut,
+        amount_sol: amountSol,
+        created_at: timestamp,
+      });
+
+      if (!error) stored++;
+    }
+
+    return NextResponse.json({ received: events.length, stored });
+  } catch (err) {
+    console.error("Webhook error:", err);
+    return NextResponse.json(
+      { error: String(err) },
+      { status: 500 }
+    );
+  }
+}

package/src/app/auth/callback/page.tsx

@@ -0,0 +1,29 @@
+"use client";
+import { useEffect } from "react";
+import { useRouter } from "next/navigation";
+import { usePhantom } from "@phantom/react-sdk";
+
+export default function AuthCallback() {
+  const router = useRouter();
+  const { isConnected } = usePhantom();
+
+  useEffect(() => {
+    if (isConnected) {
+      router.replace("/");
+    }
+  }, [isConnected, router]);
+
+  useEffect(() => {
+    const timer = setTimeout(() => router.replace("/"), 3000);
+    return () => clearTimeout(timer);
+  }, [router]);
+
+  return (
+    <div className="min-h-screen bg-[#0a0a12] flex items-center justify-center">
+      <div className="text-center">
+        <div className="w-8 h-8 border-2 border-white/20 border-t-white rounded-full animate-spin mx-auto mb-4" />
+        <p className="text-white/60 text-sm">Connecting wallet...</p>
+      </div>
+    </div>
+  );
+}