Files
trumpsignal-monorepo/apps/api/src/routes/signals.ts
T

108 lines
4.5 KiB
TypeScript

import { timingSafeEqual } from 'node:crypto'
import type { FastifyInstance } from 'fastify'
import { z } from 'zod'
import { eq, count, max, desc } from 'drizzle-orm'
import { posts } from '@trumpsignal/database'
import type { Context } from '@trumpsignal/backend/context'
import type { Services } from '@trumpsignal/backend/services'
import { requireThat, iso } from '@trumpsignal/backend/http'
import { subscription } from '@trumpsignal/backend/accounts'
import { marketBars } from '@trumpsignal/backend/market-data'
export function requireIngestKey(c: Context, key: unknown) {
const expected = c.config.ingest_api_key
requireThat(expected, 503, 'INGEST_API_KEY not configured')
requireThat(
typeof key === 'string' &&
Buffer.byteLength(key) === Buffer.byteLength(expected) &&
timingSafeEqual(Buffer.from(key), Buffer.from(expected)),
401,
'Invalid X-Ingest-Key',
)
}
export async function registerSignals(app: FastifyInstance, c: Context, s: Services) {
app.post('/api/signals/ingest', async (req) => {
requireIngestKey(c, req.headers['x-ingest-key'])
return s.pipeline.signal(req.body)
})
app.get('/api/signals/sources', async () => ({
sources: (
await c.db
.select({ source: posts.source, count: count(), latest: max(posts.published_at) })
.from(posts)
.groupBy(posts.source)
.orderBy(desc(count()))
).map((r) => ({ ...r, latest: iso(r.latest) })),
}))
app.get('/api/scanners', async () => {
const scanners = await s.scannerState.all()
return { count: scanners.length, enabled: scanners.filter((s) => s.enabled).length, scanners }
})
app.post<{ Params: { name: string } }>('/api/scanners/:name/toggle', async (req) => {
const raw = z.record(z.unknown()).parse(req.body),
name = req.params.name,
enabled = z.boolean().parse(raw.enabled)
requireThat(raw.name === name, 400, 'Scanner name mismatch')
const wallet = await c.auth.write('toggle_scanner', raw, { enabled, name })
await subscription(c, wallet)
const result = await s.scannerState.enabled(name, enabled)
requireThat(result, 404, 'Unknown scanner')
return { status: 'ok', name, enabled }
})
for (const action of ['disable', 'enable'] as const)
app.post('/api/scanners/all/' + action, async (req) => {
const raw = z.record(z.unknown()).parse(req.body),
wallet = await c.auth.write(
action === 'enable' ? 'scanner_revive_all' : 'scanner_kill_all',
raw,
null,
)
await subscription(c, wallet)
const list = await s.scannerState.all()
for (const scanner of list) await s.scannerState.enabled(scanner.name, action === 'enable')
return { status: action === 'enable' ? 'revived' : 'killed', count: list.length }
})
app.get('/api/funding/snapshot', async () => s.scanners.fundingSnapshot())
app.get('/api/signal/status', async () => ({
enabled: await s.state.get('breakout-enabled', false),
symbols: ['ETHUSDT', 'LINKUSDT'],
recent_signal_count: (await s.state.get<unknown[]>('breakout-history', [])).length,
}))
app.get('/api/signal/history', async (req) => {
const q = z
.object({ limit: z.coerce.number().int().min(1).max(200).default(20) })
.parse(req.query)
return (await s.state.get<unknown[]>('breakout-history', []))
.slice()
.reverse()
.slice(0, q.limit)
})
app.post('/api/signal/toggle', async (req) => {
requireIngestKey(c, req.headers['x-ingest-key'])
const q = z.object({ enabled: z.enum(['true', 'false']) }).parse(req.query)
await s.state.set('breakout-enabled', q.enabled === 'true')
return { enabled: q.enabled === 'true' }
})
app.get<{ Params: { asset: string } }>(
'/api/prices/:asset',
{ config: { rateLimit: { max: 30, timeWindow: '1 minute' } } },
async (req, reply) => {
const asset = z.enum(['BTC', 'ETH']).parse(req.params.asset.toUpperCase()),
q = z
.object({
tf: z.enum(['1m', '5m', '15m', '1H', '4H', '1D', '1W']).default('4H'),
limit: z.coerce.number().int().min(1).max(1000).default(200),
})
.parse(req.query)
reply.header(
'cache-control',
q.tf === '1m'
? 'public, max-age=5, stale-while-revalidate=10'
: 'public, max-age=60, stale-while-revalidate=120',
)
if (q.tf === '1m') return c.prices.candles(asset, '1m', q.limit)
const bars = await marketBars(c.config, asset, q.tf.toLowerCase(), q.limit)
return bars.map(({ time_ms, ...bar }) => bar)
},
)
}