import type { FastifyInstance } from 'fastify' import { z } from 'zod' import { and, eq, gte, desc, asc, count, sql, or, ne, isNull } from 'drizzle-orm' import { kol_posts as posts, kol_wallets as wallets, kol_holdings_snapshots as snapshots, kol_holding_changes as changes, kol_divergence as divergence, } from '@trumpsignal/database' import type { Context } from '@trumpsignal/backend/context' import { Kol, kolDto, parseArray } from '@trumpsignal/backend/kol' import { requireThat, iso } from '@trumpsignal/backend/http' import { requireIngestKey } from './signals' const query = z.object({ handle: z.string().optional(), source: z.string().optional(), ticker: z .string() .regex(/^[A-Za-z0-9]{1,12}$/) .optional(), signal_type: z.string().optional(), signals_only: z.enum(['true', 'false']).optional(), days: z.coerce.number().int().min(1).max(365).optional(), limit: z.coerce.number().int().min(1).max(200).default(50), page: z.coerce.number().int().min(1).default(1), lookback_days: z.coerce.number().int().min(1).max(90).default(30), }) const since = (days: number) => new Date(Date.now() - days * 86400000).toISOString().slice(0, -1) const walletDto = (w: typeof wallets.$inferSelect) => ({ ...w, added_at: iso(w.added_at) }) export async function registerKol(app: FastifyInstance, c: Context, kol: Kol) { app.get('/api/kol/posts', async (req) => { const q = query.parse(req.query), scope = and( q.handle ? eq(posts.kol_handle, q.handle) : undefined, q.source ? eq(posts.source, q.source) : undefined, q.signals_only === 'true' ? or(isNull(posts.tier), ne(posts.tier, 'noise')) : undefined, q.ticker ? sql`${posts.tickers_json}::jsonb @> ${JSON.stringify([{ ticker: q.ticker.toUpperCase() }])}::jsonb` : undefined, q.days ? gte(posts.published_at, since(q.days)) : undefined, ) const [rows, totals] = await Promise.all([ c.db .select() .from(posts) .where(scope) .orderBy(desc(posts.published_at)) .limit(q.limit) .offset((q.page - 1) * q.limit), c.db.select({ n: count() }).from(posts).where(scope), ]) return { items: rows.map(kolDto), page: q.page, limit: q.limit, total: totals[0].n } }) app.get<{ Params: { id: string } }>('/api/kol/posts/:id', async (req) => { const [p] = await c.db .select() .from(posts) .where(eq(posts.id, z.coerce.number().int().positive().parse(req.params.id))) .limit(1) requireThat(p, 404, 'KOL post not found') return { ...kolDto(p), raw_text: p.raw_text } }) app.get('/api/kol/digest', async (req) => { const q = query.parse(req.query) return kol.digest(Math.min(q.days ?? 7, 90)) }) app.get('/api/kol/wallets', async (req) => { const q = query.parse(req.query), rows = await c.db .select() .from(wallets) .where(and(eq(wallets.active, true), q.handle ? eq(wallets.handle, q.handle) : undefined)) .orderBy(asc(wallets.handle)) return { wallets: rows.map(walletDto) } }) app.post('/api/kol/wallets', async (req) => { requireIngestKey(c, req.headers['x-ingest-key']) const b = z .object({ handle: z.string().min(1).max(64), chain: z.string().min(1).max(16), address: z.string().min(1).max(128), label: z.string().max(128).nullable().optional(), source_url: z.string().max(256).nullable().optional(), }) .parse(req.body) const [row] = await c.db .insert(wallets) .values({ ...b, address: b.address.toLowerCase() }) .onConflictDoNothing() .returning() requireThat(row, 409, 'Wallet already tracked') return walletDto(row) }) app.get<{ Params: { id: string } }>('/api/kol/wallets/:id/snapshots', async (req) => { const id = z.coerce.number().int().positive().parse(req.params.id), q = query.parse(req.query), [w] = await c.db.select().from(wallets).where(eq(wallets.id, id)) requireThat(w, 404, 'Wallet not found') const rows = await c.db .select() .from(snapshots) .where(eq(snapshots.wallet_id, id)) .orderBy(desc(snapshots.snapshot_date)) .limit(Math.min(q.limit, 90)) return { wallet: walletDto(w), snapshots: rows.map((s) => ({ id: s.id, wallet_id: s.wallet_id, snapshot_date: s.snapshot_date, holdings: parseArray(s.holdings_json), total_usd: s.total_usd, source: s.source, created_at: iso(s.created_at), })), } }) app.get('/api/kol/changes', async (req) => { const q = query.parse(req.query), days = Math.min(q.days ?? 7, 90), cutoff = since(days), rows = await c.db .select({ change: changes, handle: wallets.handle }) .from(changes) .innerJoin(wallets, eq(changes.wallet_id, wallets.id)) .where( and( gte(changes.detected_at, cutoff), q.handle ? eq(wallets.handle, q.handle) : undefined, ), ) .orderBy(desc(changes.detected_at)) .limit(200) return { window_days: days, since: iso(cutoff), count: rows.length, changes: rows.map(({ change, handle }) => ({ ...change, handle, detected_at: iso(change.detected_at), })), } }) app.get('/api/kol/divergence', async (req) => { const q = query.parse(req.query), days = Math.min(q.days ?? 30, 180), cutoff = since(days), rows = await c.db .select() .from(divergence) .where( and( gte(divergence.post_at, cutoff), q.handle ? eq(divergence.handle, q.handle) : undefined, q.ticker ? eq(divergence.ticker, q.ticker.toUpperCase()) : undefined, q.signal_type ? eq(divergence.signal_type, q.signal_type) : undefined, ), ) .orderBy(desc(divergence.post_at), desc(divergence.created_at)) .limit(200) return { window_days: days, since: iso(cutoff), count: rows.length, items: rows.map((d) => ({ ...d, post_at: iso(d.post_at), onchain_at: iso(d.onchain_at), created_at: iso(d.created_at), })), } }) app.post('/api/kol/divergence/scan', async (req) => { requireIngestKey(c, req.headers['x-ingest-key']) const q = query.parse(req.query), items = await kol.divergence(q.lookback_days) return { new_pairs: items.length, items } }) }