跳到主要内容
Lite属于 Lite 套餐，Developer 套餐也包含。 现成的机器人随 Developer 提供，通过私有 Telegram 群获取。 查看套餐 · 获取密钥

构建 Telegram 狙击机器人

Telegram 上的一次喊单就能拉动一个币：喊单人贴出 mint，所有看到的人同时买入。最先买入的机器人拿到人群涌入之前的价格。本指南用大约一百行 Node.js 构建这样一个机器人：你自己的 Telegram 账号读取你选的聊天，Lightspeed 在 mint 贴出的那一刻用一次请求买入。如果你不想自己运行，本页末尾的现成机器人随 Developer 提供。

工作原理​

  • 用户账号，而不是机器人。 用 BotFather 创建的机器人只能读取它被拉进的聊天，频道则只有作为管理员才能读。普通账号通过 Telegram 的 API 登录后，能看到它加入的每一个聊天，和 App 里一样。用一个备用账号，不要用你自己的。
  • 帖子里的 mint。 Solana 地址是 32 到 44 个 base58 字符，pump.fun 的 mint 以 pump 结尾。机器人读取每条新帖的文字、隐藏链接和按钮，取第一个之前没见过的 mint。
  • 一次请求买入。 Lightspeed 从你的 Lightspeed 钱包构建、签名并发送买单；途中不读取任何链上数据。
  • 向你报告。 每次买入连同交易签名发到你指定的聊天：该账号的收藏夹（Saved Messages），或你自己的用户名。

你需要什么​

  • Node.js 22 或更新版本，npm install telegram input：GramJS（Telegram 客户端）和首次登录用的输入提示。
  • 一组 Telegram api_id 和 api_hash：登录 my.telegram.org，打开 API development tools，创建一个应用。
  • 一个用来监听的备用 Telegram 账号，加入你要监听的每一个聊天。Telegram 只会把账号所在聊天的帖子推送给它。
  • 一个 Lite 或 Developer 套餐（用于 Lightspeed），以及一个已充值的 Lightspeed 账户：它的 ls_… 密钥负责为买入签名。
  • 一台在 API 旁边的服务器：Lite 用法兰克福；Developer 可用法兰克福、阿姆斯特丹或纽约（见区域）。

脚本​

保存为 tg-sniper.mjs。

import { existsSync, readFileSync, writeFileSync } from "node:fs";
import input from "input";
import { TelegramClient } from "telegram";
import { StringSession } from "telegram/sessions/index.js";
import { NewMessage } from "telegram/events/index.js";

// ─── change these ─────────────────────────────────────
const API_ID        = 1234567;          // my.telegram.org → API development tools
const API_HASH      = "0123456789abcdef0123456789abcdef";
const WATCH         = [];               // chats: "username" or id; empty: list this account's chats and exit
const SENDERS       = [];               // in groups, only these user ids trigger a buy; empty: anyone
const REPORT_TO     = "me";             // "me" is Saved Messages; or your own "username"
const LS_KEY        = "ls_…";           // your Lightspeed account key
const BUY_SOL       = 0.05;             // per call
const SLIPPAGE      = 25;               // percent; a called coin moves fast
const PRIORITY_FEE  = 0.0002;           // SOL; on Lite the lever that counts (the Shrine lane takes no tip)
const TIP           = 0.001;            // SOL per provider copy, paid once by the copy that lands
const PROVIDERS     = ["all"];          // Developer: race every lane and the block 0 lane; Lite ignores it
const PUMP_ONLY     = true;             // only mints ending in "pump"
const SKIP_FORWARDS = true;             // a forward is someone else's call, posted again later
const DRY_RUN       = true;
// ──────────────────────────────────────────────────────

const API = "https://sol.shrine.trade";
const SESSION_FILE = "telegram.session";                     // the account's login: guard it like a password
const MINT_RE = /\b[1-9A-HJ-NP-Za-km-z]{32,44}\b/g;          // base58, the length of a Solana address
const senders = new Set(SENDERS.map(String));
const seen = new Set();                                      // every mint already bought or tried

async function lightspeed(body) {
  if (DRY_RUN) { console.log("  dry-run", body); return { success: true }; }
  const r = await (await fetch(`${API}/api/lightspeed`, {
    method: "POST", headers: { "content-type": "application/json", "x-api-key": LS_KEY }, body: JSON.stringify(body),
  })).json();
  if (!r.success) throw new Error(`${r.error}: ${r.message}`);
  return r;
}

// The post's text plus the links behind words and buttons ("BUY" -> pump.fun/coin/<mint>).
function textOf(msg) {
  const links = [
    ...(msg.entities ?? []).map((e) => e.url),
    ...(msg.replyMarkup?.rows ?? []).flatMap((row) => row.buttons.map((b) => b.url)),
  ];
  return [msg.message ?? "", ...links.filter(Boolean)].join(" ");
}

// 1. Log in as the listening account. The first run asks for the phone, the code and the 2FA password.
const session = new StringSession(existsSync(SESSION_FILE) ? readFileSync(SESSION_FILE, "utf8") : "");
const client = new TelegramClient(session, API_ID, API_HASH, { connectionRetries: 10 });
client.setLogLevel("error");
await client.start({
  phoneNumber: () => input.text("phone number (+44…): "),
  phoneCode: () => input.text("code Telegram sent you: "),
  password: () => input.password("2FA password: "),
  onError: (e) => console.error(e.message),
});
writeFileSync(SESSION_FILE, client.session.save());

if (!WATCH.length) {                                         // no chats yet: print the ones this account is in
  for (const d of await client.getDialogs({ limit: 200 })) console.log(String(d.id).padEnd(16), d.title);
  process.exit(0);
}
const chats = await Promise.all(WATCH.map((c) => client.getPeerId(c)));   // usernames to ids now, not on the first post

// 2. Every new post in a watched chat: find a mint, buy it once.
client.addEventHandler(async (event) => {
  const msg = event.message;
  if (SKIP_FORWARDS && msg.fwdFrom) return;
  if (senders.size && !senders.has(String(msg.senderId))) return;
  const mint = [...textOf(msg).matchAll(MINT_RE)].map((m) => m[0])
    .find((m) => !seen.has(m) && (!PUMP_ONLY || m.endsWith("pump")));
  if (!mint) return;
  seen.add(mint);                                            // before the request: a repost cannot buy it again
  const lag = Date.now() / 1000 - msg.date;                  // msg.date is whole seconds: an upper bound
  console.log(`call ${mint} in ${event.chatId} from ${msg.senderId}, ≤${lag.toFixed(1)} s after the post`);
  const t0 = performance.now();
  try {
    const r = await lightspeed({
      action: "buy", mint, amount: BUY_SOL, slippage: SLIPPAGE,
      priorityFee: PRIORITY_FEE, tip: TIP, providers: PROVIDERS,
    });
    console.log(`  sent in ${(performance.now() - t0).toFixed(0)} ms: ${r.signature ?? "dry"}`);
    // 3. Report it. Not awaited: the buy is already out.
    client.sendMessage(REPORT_TO, { message: `bought ${mint}\n${r.signature ?? "dry run"}` }).catch(() => {});
  } catch (e) {
    console.error(`  buy failed: ${e.message}`);
  }
}, new NewMessage({ chats }));                               // new posts only: edits are another event

console.log(`watching ${chats.length} chats`);

运行​

  1. 登录并列出你的聊天。 WATCH 留空，运行 node tg-sniper.mjs。它会询问手机号、Telegram 发来的验证码，以及账号设了两步验证时的 2FA 密码，把登录信息保存到 telegram.session，然后打印该账号所在的每一个聊天及其 id。
  2. 选定聊天。 把它们的用户名或 id 填进 WATCH。私密聊天没有用户名：用首次运行打印出的 id。
  3. 试运行。 DRY_RUN = true 时，它会打印每一个它本会买入的喊单、谁发的，以及它在帖子发出多久后看到。让它跑过几次喊单，检查它本会买些什么。
  4. 正式运行。 DRY_RUN = false，设一个小的 BUY_SOL，盯着最初几笔成交。

每个部分做什么​

  • 读取帖子。 喊单人常把 mint 藏在一个词或一个指向 pump.fun 的按钮后面，所以 textOf 把这些链接也并入文字。正则匹配任何形如 Solana 地址的字符串；PUMP_ONLY 只保留以 pump 结尾的，顺带去掉帖子里引用的钱包地址和池子地址。
  • 筛选。 只有 WATCH 里聊天的帖子会进入处理函数。在群里，SENDERS 把范围限定在你信任的喊单人，这样群成员随手贴个 mint 不会触发买入；试运行会打印每个发帖人的 id。转发会被跳过：转发是别处更早的喊单的重复。编辑不会到达，因为 NewMessage 只管新帖；有的聊天先发帖、再把 mint 编辑进去，对这种情况 GramJS 在 telegram/events/EditedMessage.js 里提供 EditedMessage。
  • 每个 mint 只买一次。 Telegram 有时会把同一条帖子推送两次，一次喊单也会在几秒内被多个频道转贴。mint 在请求发出之前就放进 seen，所以第二次看到它，哪怕是在第一笔买入还在途中时到达，也不会再买。
  • 买入。 一次 Lightspeed 请求，amount 以 SOL 计。Lightspeed 根据自己的缓存路由：还在联合曲线上的币在 pump.fun 上买，已毕业的在 PumpSwap 上买。不是可交易代币的地址会返回错误，什么都不会发出。
  • 费用。 在 Lite 上，买单只经 Shrine 质押通道发出，这条通道不收小费：喊单拥挤时提高 PRIORITY_FEE。在 Developer 上，副本相互竞速；每份回滚的副本支付自己的优先费，只有落地的那份支付小费，所以预算应放在 TIP 上。
  • 延迟那一行。 msg.date 是 Telegram 收下帖子的时间，精确到整秒，所以 ≤1.4 s 表示介于 0.4 到 1.4 秒之间。保持服务器时钟同步：时钟偏差半秒，这个数字就偏差半秒。

退出​

脚本买入后就停在那里。要设目标价、止损和定时，就跟踪这个币的交易并通过 Lightspeed 卖出，做法和狙击指南一样。subscribe_trades 直接接受 mint，所以一次喊单不需要别的信息：

import { io } from "socket.io-client";

const socket = io("https://sol.shrine.trade", { transports: ["websocket"] });

// after a buy:
socket.emit("subscribe_trades", { mint });
// then the sniper guide's "trade" handler: entry, target, stop, timer, one "100%" sell

时间花在哪里​

步骤耗时
喊单人按下发送，帖子到达你的账号约 0.5 到 2 秒，在 Telegram 一侧
找到 mint、筛选远低于 1 毫秒
从同一城市发出的请求到达 Lightspeed约 1 毫秒
从发出到落地Lite 约 100 ms，Developer 竞速约 50 ms
  • Telegram 是慢的那一段。 推送要约 0.5 到 2 秒，随聊天和时刻而变。没有机器人能比它快；你的机器人能做的只是不再额外增加延迟。帖子到达之后的一切都应该在毫秒级完成。
  • 靠近 Telegram，也靠近 API。 Telegram 的欧洲数据中心在阿姆斯特丹，欧洲号码的账号通常由那里服务。在法兰克福或阿姆斯特丹的监听程序离 Telegram 和 API 都只有几毫秒；放在另一个大洲，每个方向都要多跨一次大洋。
  • 途中什么都不做。 让 Lightspeed 钱包保持有余额，在帖子和请求之间不查询任何东西：不查余额，不查元数据，不读链。筛选只用你手上已有的文字。
  • 只开一个监听程序。 每个账号一个连接。同一个 session 同时在两个地方使用会被 Telegram 吊销，而且两个监听程序会把同一次喊单各买一次。
  • 转贴去重。 同一个 mint 会在几秒内从多个频道到达；没有 seen，每一次都是一笔买入。
  • Developer 上的竞速。 在 Lite 上，买单经 Shrine 质押通道发出，约 100 ms 落地。Developer 同时竞速全部 8 条 SWQoS 通道和 0 区块通道，约 50 ms（见多服务商竞速）；当群里每个机器人同时出手时，决定落在哪个 slot（槽位）的就是它。

安全​

  • 先试运行。 在任何 SOL 动之前，用 DRY_RUN = true 看几次喊单。筛选写错，就会买下每条帖子里的每个地址。
  • 小额。 Lightspeed 钱包里只放你用来狙击的钱，不要更多，盈利及时提出。
  • 喊单不等于理由。 很多喊单是付费的，很多币就是卖给喊单带来的买家，还有人用同名同代号、mint 不同的仿盘来钓快速机器人。只监听你信任的喊单人，保持 SENDERS 和 PUMP_ONLY 开启。
  • 密钥只属于你。 永远不要把你的 Lightspeed 密钥、私钥或 telegram.session 贴进任何聊天或机器人：session 文件就是这个账号的完整登录。任何向你索要它们的人，包括自称"客服"的，都是骗子。

现成的机器人​

我们自己运行着一个 Telegram 狙击机器人，它随 Developer 套餐提供：

  • 监听你设定的聊天。 频道和群，由你来选。
  • 通过竞速买入。 和上面相同的一次请求流程，在 Lightspeed 的各条通道上竞速。
  • 在迁移时买入。 被喊的币联合曲线已满时，它在迁移那一刻于 PumpSwap 上买入。
  • 一切都在 Telegram 里。 每次买入都会报告到你的 Telegram，机器人也通过一个 Telegram 机器人来操作。

获取方式：

  1. 开通 Developer。 在价格页面比较各套餐，然后在控制台开通 Developer。
  2. 加入私有群。 仅限邀请；Developer 生效后，邀请链接就在你的控制台上。
  3. 申请机器人。 在群里发帖，我们为你开通。

Developer 还带来覆盖每条通道和 0 区块通道的多服务商竞速、全部三个区域，以及供你自己的机器人使用的 Ultra Fast Shred Stream（超快分片流）。见套餐与限额。