How to Integrate Bolt.new with Binance API

1// lib/binance.ts
2export const BINANCE_BASE_URL =
3  process.env.BINANCE_BASE_URL || 'https://api.binance.com';
4
5export const BINANCE_WS_URL =
6  process.env.BINANCE_WS_URL || 'wss://stream.binance.com:9443';
7
8// For Testnet, use:
9// BINANCE_BASE_URL=https://testnet.binance.vision
10// BINANCE_WS_URL=wss://testnet.binance.vision/ws
11
12export async function binancePublicFetch<T = unknown>(
13  endpoint: string,
14  params?: Record<string, string>
15): Promise<T> {
16  const url = new URL(`${BINANCE_BASE_URL}${endpoint}`);
17  if (params) {
18    Object.entries(params).forEach(([key, value]) => {
19      url.searchParams.set(key, value);
20    });
21  }
22
23  const response = await fetch(url.toString());
24  if (!response.ok) {
25    const error = await response.json().catch(() => ({})) as { msg?: string; code?: number };
26    throw new Error(error.msg || `Binance API error ${response.status}`);
27  }
28
29  return response.json() as Promise<T>;
30}
31
32export interface BinanceTicker {
33  symbol: string;
34  price: number;
35  priceChange: number;
36  priceChangePercent: number;
37  volume: number;
38  quoteVolume: number;
39  high: number;
40  low: number;
41  count: number;
42}
43
44export function parseTicker(raw: Record<string, string>): BinanceTicker {
45  return {
46    symbol: raw.symbol,
47    price: parseFloat(raw.lastPrice || raw.price),
48    priceChange: parseFloat(raw.priceChange || '0'),
49    priceChangePercent: parseFloat(raw.priceChangePercent || '0'),
50    volume: parseFloat(raw.volume || '0'),
51    quoteVolume: parseFloat(raw.quoteVolume || '0'),
52    high: parseFloat(raw.highPrice || '0'),
53    low: parseFloat(raw.lowPrice || '0'),
54    count: parseInt(raw.count || '0', 10),
55  };
56}

1// app/api/binance/klines/route.ts
2import { NextResponse } from 'next/server';
3import { binancePublicFetch } from '@/lib/binance';
4
5type RawKline = [
6  number, // openTime
7  string, // open
8  string, // high
9  string, // low
10  string, // close
11  string, // volume
12  number, // closeTime
13  string, // quoteVolume
14  number, // tradeCount
15  string, // takerBuyBaseVolume
16  string, // takerBuyQuoteVolume
17  string  // ignore
18];
19
20export async function GET(request: Request) {
21  const { searchParams } = new URL(request.url);
22  const symbol = (searchParams.get('symbol') || 'BTCUSDT').toUpperCase();
23  const interval = searchParams.get('interval') || '1d';
24  const limit = searchParams.get('limit') || '100';
25
26  // Validate interval to prevent injection
27  const validIntervals = ['1m','3m','5m','15m','30m','1h','2h','4h','6h','8h','12h','1d','3d','1w','1M'];
28  if (!validIntervals.includes(interval)) {
29    return NextResponse.json({ error: 'Invalid interval' }, { status: 400 });
30  }
31
32  try {
33    const klines = await binancePublicFetch<RawKline[]>('/api/v3/klines', {
34      symbol,
35      interval,
36      limit,
37    });
38
39    const candles = klines.map((k) => ({
40      time: Math.floor(k[0] / 1000), // Convert ms to seconds for lightweight-charts
41      open: parseFloat(k[1]),
42      high: parseFloat(k[2]),
43      low: parseFloat(k[3]),
44      close: parseFloat(k[4]),
45      volume: parseFloat(k[5]),
46    }));
47
48    return NextResponse.json({ symbol, interval, candles });
49  } catch (err) {
50    const message = err instanceof Error ? err.message : 'Failed to fetch klines';
51    return NextResponse.json({ error: message }, { status: 500 });
52  }
53}

1// Addition to lib/binance.ts — private signed requests
2import crypto from 'crypto';
3
4export async function binancePrivateFetch<T = unknown>(
5  endpoint: string,
6  method: 'GET' | 'POST' | 'DELETE' = 'GET',
7  params: Record<string, string | number | boolean> = {}
8): Promise<T> {
9  const apiKey = process.env.BINANCE_API_KEY;
10  const secretKey = process.env.BINANCE_SECRET_KEY;
11  const baseUrl = process.env.BINANCE_BASE_URL || 'https://api.binance.com';
12
13  if (!apiKey || !secretKey) {
14    throw new Error('BINANCE_API_KEY and BINANCE_SECRET_KEY must be configured in .env. Use Testnet keys from testnet.binance.vision for development.');
15  }
16
17  // Add required timestamp
18  const allParams = { ...params, timestamp: Date.now() };
19
20  // Build query string
21  const queryString = Object.entries(allParams)
22    .map(([key, value]) => `${key}=${encodeURIComponent(String(value))}`)
23    .join('&');
24
25  // Compute HMAC-SHA256 signature
26  const signature = crypto
27    .createHmac('sha256', secretKey)
28    .update(queryString)
29    .digest('hex');
30
31  const signedQuery = `${queryString}&signature=${signature}`;
32  const url = `${baseUrl}${endpoint}?${signedQuery}`;
33
34  const response = await fetch(url, {
35    method,
36    headers: {
37      'X-MBX-APIKEY': apiKey,
38      'Content-Type': 'application/json',
39    },
40  });
41
42  if (!response.ok) {
43    const error = await response.json().catch(() => ({})) as { msg?: string; code?: number };
44    throw new Error(error.msg || `Binance API error ${response.status} (code: ${error.code})`);
45  }
46
47  return response.json() as Promise<T>;
48}

1// app/api/binance/order/route.ts
2import { NextResponse } from 'next/server';
3import { binancePrivateFetch } from '@/lib/binance-private';
4
5const BINANCE_ERROR_MESSAGES: Record<number, string> = {
6  '-2010': 'Insufficient balance to place this order',
7  '-1121': 'Invalid trading symbol — check the symbol format (e.g., BTCUSDT)',
8  '-1013': 'Order quantity below minimum lot size for this trading pair',
9  '-1100': 'Invalid parameter value — check quantity and price format',
10  '-2011': 'Order does not exist or already canceled',
11};
12
13interface BinanceOrderResult {
14  orderId: number;
15  symbol: string;
16  status: string;
17  executedQty: string;
18  cummulativeQuoteQty: string;
19  price: string;
20  side: string;
21  type: string;
22}
23
24export async function POST(request: Request) {
25  const { symbol, side, type, quantity, price, timeInForce, testMode = true } = await request.json();
26
27  // Validate required fields
28  if (!symbol || !side || !type || !quantity) {
29    return NextResponse.json({ error: 'symbol, side, type, and quantity are required' }, { status: 400 });
30  }
31
32  // Basic validation
33  if (!['BUY', 'SELL'].includes(side.toUpperCase())) {
34    return NextResponse.json({ error: 'side must be BUY or SELL' }, { status: 400 });
35  }
36
37  if (parseFloat(quantity) <= 0) {
38    return NextResponse.json({ error: 'quantity must be positive' }, { status: 400 });
39  }
40
41  const orderParams: Record<string, string | number> = {
42    symbol: symbol.toUpperCase(),
43    side: side.toUpperCase(),
44    type: type.toUpperCase(),
45    quantity: String(quantity),
46  };
47
48  if (type.toUpperCase() === 'LIMIT') {
49    if (!price) return NextResponse.json({ error: 'price required for LIMIT orders' }, { status: 400 });
50    orderParams.price = String(price);
51    orderParams.timeInForce = timeInForce || 'GTC';
52  }
53
54  try {
55    // Always test order first
56    await binancePrivateFetch('/api/v3/order/test', 'POST', orderParams);
57
58    if (testMode) {
59      return NextResponse.json({
60        testMode: true,
61        message: 'Order validation passed. Set testMode: false to place the real order.',
62        params: orderParams,
63      });
64    }
65
66    const result = await binancePrivateFetch<BinanceOrderResult>(
67      '/api/v3/order',
68      'POST',
69      orderParams
70    );
71
72    return NextResponse.json({
73      orderId: result.orderId,
74      symbol: result.symbol,
75      status: result.status,
76      executedQty: parseFloat(result.executedQty),
77      price: parseFloat(result.price) || null,
78      side: result.side,
79      type: result.type,
80    });
81  } catch (err) {
82    const message = err instanceof Error ? err.message : 'Order placement failed';
83    // Extract Binance error code from message
84    const codeMatch = message.match(/code: (-?\d+)/);
85    const friendlyMessage = codeMatch
86      ? BINANCE_ERROR_MESSAGES[parseInt(codeMatch[1])] || message
87      : message;
88    return NextResponse.json({ error: friendlyMessage }, { status: 400 });
89  }
90}