108 lines
4.5 KiB
TypeScript
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)
|
|
},
|
|
)
|
|
}
|