chore: hubble ai

Author: sukbearai

.github/workflows/deploy-cloudflare.yml

@@ -63,6 +63,7 @@ jobs:
           deepseekApiKey: ${{ secrets.DEEPSEEK_API_KEY }}
           twitterApiKey: ${{ secrets.TWITTER_API_KEY }}
           aiMedsciApiToken: ${{ secrets.AI_MEDSCI_API_TOKEN }}
+          hubbleApiKey: ${{ secrets.HUBBLE_API_KEY }}
 
       - name: Deploy to Cloudflare Workers
         uses: cloudflare/wrangler-action@v3
@@ -84,6 +85,7 @@ jobs:
             deepseekApiKey
             twitterApiKey
             aiMedsciApiToken
+            hubbleApiKey
         env:
           appId: ${{ secrets.APP_ID }}
           appSecret: ${{ secrets.APP_SECRET }}
@@ -95,3 +97,4 @@ jobs:
           deepseekApiKey: ${{ secrets.DEEPSEEK_API_KEY }}
           twitterApiKey: ${{ secrets.TWITTER_API_KEY }}
           aiMedsciApiToken: ${{ secrets.AI_MEDSCI_API_TOKEN }}
+          hubbleApiKey: ${{ secrets.HUBBLE_API_KEY }}

apps/congrong-private-api/bot/index.ts

@@ -17,9 +17,10 @@ class TelegramBotSingleton {
         },
       }
 
+      // eslint-disable-next-line node/prefer-global/process
       const isProduction = process.env.NODE_ENV === 'production'
 
-      if (telegram.proxyUrl && !isProduction) {
+      if (telegram.proxyUrl && !isProduction && telegram.proxyUrl.startsWith('socks')) {
         clientOptions.client.baseFetchConfig.agent = new SocksProxyAgent(telegram.proxyUrl)
       }
 

apps/congrong-private-api/nitro.config.ts

@@ -105,6 +105,9 @@ export default defineNitroConfig({
       apiKey: process.env.twitterApiKey,
     },
     aiMedsciApiToken: process.env.aiMedsciApiToken,
+    hubble: {
+      apiKey: process.env.HUBBLE_API_KEY,
+    },
   },
 
   preset: 'cloudflare_module',

apps/congrong-private-api/server/middleware/jwt.ts

@@ -27,6 +27,8 @@ export default defineEventHandler(async (event) => {
     '/exchanges',
     '/finance',
     '/api/thirdparty/twitter',
+    '/webhooks',
+    '/hubble',
   ]
 
   // 需要特殊token鉴权的路径

apps/congrong-private-api/server/middleware/token.ts

@@ -6,6 +6,10 @@
 export default defineEventHandler(async (event) => {
   const { appId, appSecret } = useRuntimeConfig(event)
 
+  if (event.path.startsWith('/webhooks') || event.path.startsWith('/telegram') || event.path.startsWith('/hubble')) {
+    return
+  }
+
   if (!appId || !appSecret) {
     return createErrorResponse('请配置 appId 和 appSecret 环境变量', 500)
   }

apps/congrong-private-api/server/routes/hubble/signals.get.ts

@@ -0,0 +1,20 @@
+import { hubbleApi } from '~/utils/hubble'
+
+export default eventHandler(async (event) => {
+  const query = getQuery(event)
+  try {
+    const res = await hubbleApi.getSignalList({
+      name: query.name as string,
+      status: query.status as 'ongoing' | 'paused',
+      page: Number(query.page) || 1,
+      size: Number(query.size) || 10,
+    })
+    return res
+  }
+  catch (e) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: String(e),
+    })
+  }
+})

apps/congrong-private-api/server/routes/hubble/signals.post.ts

@@ -0,0 +1,34 @@
+import { hubbleApi, type HubbleSignalConfig } from '~/utils/hubble'
+
+export default eventHandler(async (event) => {
+  const body = await readBody(event)
+
+  if (!body.callback_url) {
+    throw createError({ statusCode: 400, message: 'Missing callback_url' })
+  }
+
+  // Default configuration for a broad CEX monitor if minimal params provided
+  const config: HubbleSignalConfig = {
+    name: body.name || `CEX Monitor ${new Date().toISOString()}`,
+    callback_url: body.callback_url,
+    chain: body.chain || 'ETH',
+    activity: 'CEX',
+    action: body.action || 'Inflow',
+    exchanges: body.exchanges || ['All'],
+    token_addresses: body.token_addresses || [],
+    wallet_addresses: body.wallet_addresses || [],
+    min_amount: body.min_amount,
+    max_amount: body.max_amount,
+  }
+
+  try {
+    const res = await hubbleApi.createSignal(config)
+    return res
+  }
+  catch (e) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: String(e),
+    })
+  }
+})

apps/congrong-private-api/server/routes/hubble/webhook.post.ts

@@ -0,0 +1,26 @@
+import { bot } from '~/utils/bot'
+import { getTelegramChannel } from '~/utils/telegram'
+
+export default eventHandler(async (event) => {
+  const body = await readBody(event)
+
+  try {
+    const channelId = getTelegramChannel('signal:cex')
+    
+    // Format message
+    // Since we don't know the exact structure yet, we dump the JSON
+    // formatted as a code block.
+    const message = `📡 **Hubble Signal Received**\n\n\`\`\`json\n${JSON.stringify(body, null, 2)}\n\`\`\``
+
+    await bot.api.sendMessage(channelId, message, { parse_mode: 'Markdown' })
+
+    return { status: 'received' }
+  } catch (error) {
+    console.error('Error processing Hubble webhook:', error)
+    // Always return 200 to Hubble even if forwarding fails, 
+    // to prevent them from retrying excessively if it's a logic error on our end.
+    // Ideally we might want to distinguish between our errors and theirs,
+    // but ensuring the webhook acknowledges receipt is priority.
+    return { status: 'error', message: String(error) }
+  }
+})

apps/congrong-private-api/server/routes/webhooks/signal/cex.post.ts

@@ -0,0 +1,54 @@
+export default eventHandler(async (event) => {
+  const body = await readBody(event)
+  const channelId = getTelegramChannel('signal:cex')
+
+  try {
+    const { chain, type, amount, symbol, sender, receiver, tags, signature } = body
+
+    const isInflow = type?.toLowerCase() === 'inflow'
+    const emoji = isInflow ? '🟢' : '🔴'
+    const typeStr = isInflow ? 'Inflow \\(充值\\)' : 'Outflow \\(提现\\)'
+
+    // Construct Etherscan/Solscan link based on chain
+    let txLink = `\`${signature}\``
+    if (chain === 'ETH') {
+      txLink = `[${escapeMarkdown(shorten(signature))}](https://etherscan.io/tx/${signature})`
+    }
+    else if (chain === 'SOL') {
+      txLink = `[${escapeMarkdown(shorten(signature))}](https://solscan.io/tx/${signature})`
+    }
+
+    const message = `
+${emoji} *CEX ${typeStr} Alert*
+
+*Amount:* \`${amount} ${symbol}\`
+*Chain:* ${escapeMarkdown(chain)}
+*Exchange/Tag:* ${escapeMarkdown(tags || 'Unknown')}
+
+*Sender:* \`${shorten(sender)}\`
+*Receiver:* \`${shorten(receiver)}\`
+*Tx:* ${txLink}
+
+\\#CEX \\#${escapeMarkdown(symbol)} \\#${escapeMarkdown(type)}
+`.trim()
+
+    await bot.api.sendMessage(channelId, message, {
+      parse_mode: 'MarkdownV2',
+      link_preview_options: { is_disabled: true },
+    })
+
+    return { status: 'ok' }
+  }
+  catch (error) {
+    console.error('Error processing CEX signal webhook:', error)
+    // Return 200 to acknowledge receipt even if processing fails to prevent retries (or depending on policy)
+    // But usually webhook senders want 200.
+    return { status: 'error', message: String(error) }
+  }
+})
+
+function shorten(str: string | undefined) {
+  if (!str) { return 'N/A' }
+  if (str.length < 10) { return str }
+  return `${str.slice(0, 6)}...${str.slice(-4)}`
+}

apps/congrong-private-api/server/utils/hubble.ts

@@ -0,0 +1,99 @@
+const BASE_URL = 'https://api.hubble.xyz'
+
+export interface HubbleSignalConfig {
+  name: string
+  callback_url: string
+  chain: 'ETH' | 'SOL'
+  activity: 'CEX'
+  action: 'Inflow' | 'Outflow'
+  exchanges: string[] // e.g. ["Binance", "OKX"] or ["All"]
+  token_addresses?: string[] // Optional
+  wallet_addresses?: string[] // Optional
+  min_amount?: string
+  max_amount?: string
+}
+
+interface HubbleResponse<T = any> {
+  code: number
+  message: string
+  data?: T
+}
+
+export const hubbleApi = {
+  /**
+   * Create a new signal configuration
+   */
+  async createSignal(config: HubbleSignalConfig) {
+    return await this.request('/signal/config', 'POST', config)
+  },
+
+  /**
+   * Get list of signals
+   */
+  async getSignalList(params?: { name?: string, status?: 'ongoing' | 'paused', page?: number, size?: number }) {
+    const query = new URLSearchParams()
+    if (params?.name) { query.append('name', params.name) }
+    if (params?.status) { query.append('status', params.status) }
+    if (params?.page) { query.append('page', String(params.page)) }
+    if (params?.size) { query.append('size', String(params.size)) }
+
+    return await this.request(`/signal/config?${query.toString()}`, 'GET')
+  },
+
+  /**
+   * Update a signal configuration
+   */
+  async updateSignal(webhookId: string, config: Partial<HubbleSignalConfig>) {
+    return await this.request(`/signal/config/${webhookId}`, 'PUT', config)
+  },
+
+  /**
+   * Pause or Activate a signal
+   */
+  async setSignalStatus(webhookId: string, status: 'ongoing' | 'paused') {
+    return await this.request(`/signal/config/${webhookId}`, 'PATCH', { status })
+  },
+
+  /**
+   * Delete a signal
+   */
+  async deleteSignal(webhookId: string) {
+    return await this.request(`/signal/config/${webhookId}`, 'DELETE')
+  },
+
+  /**
+   * Internal request helper
+   */
+  async request(path: string, method: string, body?: any) {
+    const { hubble } = useRuntimeConfig()
+    if (!hubble.apiKey) {
+      throw new Error('HUBBLE_API_KEY is not configured')
+    }
+
+    // Replace {YOUR HUBBLE-API-KEY} with actual key
+    const headers = {
+      'Content-Type': 'application/json',
+      'HUBBLE-API-KEY': hubble.apiKey,
+    }
+
+    try {
+      const response = await fetch(`${BASE_URL}${path}`, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : undefined,
+      })
+
+      const data = await response.json() as HubbleResponse
+
+      if (!response.ok) {
+        throw new Error(`Hubble API Error: ${response.status} ${response.statusText} - ${JSON.stringify(data)}`)
+      }
+
+      return data
+    }
+    catch (error) {
+      console.error('Hubble API Request Failed:', error)
+      throw error
+    }
+  },
+}