跳到主要内容

构建 X 狙击机器人

X 上的一条帖子就能拉动一个币:开发者贴出刚发射的币的 mint,有粉丝的账号点名一个币,所有看到的机器人同时买入。最先买入的机器人拿到人群涌入之前的价格。本指南用一百多行 Node.js 构建这样一个机器人:Shrine 的 X stream(X 帖子流)推送你选的账号的每条新帖,机器人从中找出 mint,Lightspeed 用一次请求买入,并在每条通道上竞速。X stream 随 Professional 提供。

工作原理​

  • 帖子推送给你。 你指定最多 50 个 X 账号,X stream 把它们的每条新帖作为 tweet 事件推送给你,帖子发出几秒之内就到。你这边不需要 X 账号,不需要 X API 密钥,也不用抓取网页。对开启了转帖的账号,它们的转帖也会推送。
  • 帖子里的 mint。 Solana 地址是 32 到 44 个 base58 字符,pump.fun 的 mint 以 pump 结尾。机器人读取每条帖子的文字,取第一个之前没见过的 mint。文字里没有时,它查看帖子中的 t.co 短链接指向哪里。
  • 一次请求买入。 Lightspeed 从你的 Lightspeed 钱包构建、签名并发送买单,同时经全部 SWQoS 通道和 0 区块通道发出;途中不读取任何链上数据。
  • 向你报告。 每次买入都会连同交易签名和触发它的帖子一起打印出来;如果你给脚本配了一个 Telegram 机器人,还会发到你的 Telegram。

你需要什么​

  • Node.js 22 或更新版本,npm install socket.io-client。
  • 一个 Professional 套餐及其密钥(sk_…,在控制台上):它开通 X stream。流服务器的地址也在控制台上,并标明每台是否在线。
  • 一个为这个机器人专门创建、已充值的 Lightspeed 账户:它的 ls_… 密钥负责为买入签名。
  • 要关注的 X 用户名(handle),最多 50 个。
  • 一台在 API 旁边的服务器:法兰克福、阿姆斯特丹或纽约(见区域)。流服务器分布在美国、欧洲和亚洲:连接离你的服务器最近的那台。
  • 可选,用于在 Telegram 上接收报告:一个用 @BotFather 创建的机器人。用你自己的账号给它发 /start,然后打开 https://api.telegram.org/bot<token>/getUpdates,从返回内容里取出你的 chat id。

脚本​

保存为 x-sniper.mjs。

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

// ─── change these ─────────────────────────────────────
const STREAM_KEY = "sk_…"; // your Professional plan's key: it opens the X stream
const SERVERS = ["https://YOUR_STREAM_SERVER"]; // from your dashboard; with several, the first copy of a post wins
const ACCOUNTS = [ // X handles to follow, up to 50
"dev_handle",
{ user: "caller_handle", reposts: true }, // their reposts too
];
const TRIGGERS = []; // handles whose posts may buy; empty: every account above
const LS_KEY = "ls_…"; // your Lightspeed account key
const BUY_SOL = 0.05; // per post
const AMOUNTS = {}; // per account, lower case: { dev_handle: 0.2 }
const SLIPPAGE = 25; // percent; a posted coin moves fast
const PRIORITY_FEE = 0.0002; // SOL; every copy that reverts pays it too
const TIP = 0.001; // SOL per provider copy, paid once by the copy that lands
const PROVIDERS = ["all"]; // race every lane and the block 0 lane
const PUMP_ONLY = true; // only mints ending in "pump"
const RESOLVE_LINKS = true; // no mint in the text: look where its t.co links point
const MAX_AGE_S = 15; // skip a post that reaches you later than this
const REPORT_BOT = ""; // optional: a Telegram bot's token from @BotFather ...
const REPORT_CHAT = ""; // ... and your chat id with it; empty: the console only
const DRY_RUN = true;
// ──────────────────────────────────────────────────────

const API = "https://sol.shrine.trade";
const MINT_RE = /\b[1-9A-HJ-NP-Za-km-z]{32,44}\b/g; // base58, the length of a Solana address
const LINK_RE = /https?:\/\/t\.co\/\w+/g; // X's short links
const FATAL = new Set(["api_key_required", "unknown_key", "key_disabled", "plan_required"]);
const triggers = new Set(TRIGGERS.map((h) => h.replace(/^@/, "").toLowerCase()));
const seen = new Set(); // every mint already bought or tried
const posts = new Set(); // post ids already read, from any server

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;
}

// To the console, and to your Telegram when REPORT_BOT is set. Not awaited: the buy is already out.
function report(text) {
console.log(text);
if (!REPORT_BOT) return;
fetch(`https://api.telegram.org/bot${REPORT_BOT}/sendMessage`, {
method: "POST", headers: { "content-type": "application/json" },
body: JSON.stringify({ chat_id: REPORT_CHAT, text, link_preview_options: { is_disabled: true } }),
}).catch(() => {});
}

const fresh = (m) => !seen.has(m) && (!PUMP_ONLY || m.endsWith("pump"));
const mintIn = (text) => [...text.matchAll(MINT_RE)].map((m) => m[0]).find(fresh);

// Where a short link points: t.co's redirect names it, nothing past it is fetched.
async function target(link) {
try {
const r = await fetch(link, { redirect: "manual", signal: AbortSignal.timeout(2000) });
return r.headers.get("location") ?? (await r.text()); // some answers carry it in a small page instead
} catch { return ""; }
}

async function buy(mint, why, amount = BUY_SOL) {
seen.add(mint); // before the request: a second post cannot buy it again
const t0 = performance.now();
try {
const r = await lightspeed({
action: "buy", mint, amount, slippage: SLIPPAGE,
priorityFee: PRIORITY_FEE, tip: TIP, providers: PROVIDERS,
});
const ms = (performance.now() - t0).toFixed(0);
const lanes = r.submissions ? `, ${r.submissions.filter((s) => s.accepted).length} lanes took it` : "";
report(`bought ${amount} SOL of ${mint}\n${why}\nsent in ${ms} ms${lanes}\n` +
(r.signature ? `https://solscan.io/tx/${r.signature}` : "dry run"));
} catch (e) {
report(`buy of ${mint} failed: ${e.message}\n${why}`);
}
}

// Every new post: find a mint, buy it once.
async function onTweet(t) {
if (posts.has(t.id)) return; // the same post from a second server
posts.add(t.id);
const who = t.user.toLowerCase();
const age = (Date.now() - t.postedAt) / 1000;
console.log(`@${t.user} ${t.kind}, X→stream ${t.receivedAt - t.postedAt} ms, →you ${age.toFixed(2)} s: ${t.text.slice(0, 80)}`);
if (triggers.size && !triggers.has(who)) return; // followed to read, not to buy
if (age > MAX_AGE_S) return; // late: the crowd has bought it already
let mint = mintIn(t.text);
if (!mint && RESOLVE_LINKS) {
for (const link of t.text.match(LINK_RE) ?? []) if ((mint = mintIn(await target(link)))) break;
}
if (!mint) return;
await buy(mint, `${t.kind} by @${t.user}: ${t.url}`, AMOUNTS[who] ?? BUY_SOL);
}

// One socket per server. Follows belong to the socket: subscribe again on every (re)connect.
for (const server of SERVERS) {
const socket = io(server, { auth: { api_key: STREAM_KEY }, transports: ["websocket"] });
let stopped = false;
socket.on("connect", () => {
socket.emit("subscribe_tweets", { users: ACCOUNTS }, (ack) => {
if (!ack.ok) return console.error(`${server}: ${ack.error} ${ack.message ?? ""}`);
for (const u of ack.users) console.log(`${server}: @${u.user} ${u.status} ${u.message ?? ""}`);
if (ack.rejected) console.log(`${server}: not on X:`, ack.rejected);
console.log(`${server}: following ${ack.users.length} of ${ack.max}, feed ${ack.feed}`);
});
});
socket.on("tweet", onTweet);
socket.on("tweet_user", (u) => console.log(`${server}: @${u.user} ${u.status} ${u.message ?? ""}`));
socket.on("subscription_error", (e) => { // the plan ended or the key was switched off
if (FATAL.has(e.error)) { stopped = true; console.error(`${server}: ${e.error}`); }
});
socket.on("connect_error", (e) => { // refused at the handshake: Socket.IO won't retry on its own
console.error(`${server}: ${e.message}`);
if (!socket.active && !FATAL.has(e.message)) setTimeout(() => socket.connect(), 5000);
});
socket.on("disconnect", (reason) => { // a server update closes the socket once
console.error(`${server}: disconnected (${reason})`);
if (reason === "io server disconnect" && !stopped) setTimeout(() => socket.connect(), 1000);
});
}

console.log(`watching ${ACCOUNTS.length} X accounts on ${SERVERS.length} server(s)`);

运行​

  1. 填好顶部配置。 你的套餐密钥、控制台上一台流服务器的地址、要关注的账号,以及你的 Lightspeed 密钥。
  2. 试运行。 DRY_RUN = true 时,它会连接,在每个账号上线时打印出来(或打印无法关注的原因),然后打印每条帖子:谁发的、到达流服务器和到达你各用了多久,以及它本会发出的买单。让它跑过几条帖子,检查它本会买些什么。
  3. 正式运行。 DRY_RUN = false,设一个小的 BUY_SOL,盯着最初几笔成交。

每个部分做什么​

  • 关注。 每次连接都会执行 subscribe_tweets,因为关注属于 socket:重连后的 socket 在重新订阅之前什么都不关注。ack 列出每个账号的状态:live;pending 表示正在设置(设置好后会收到一个 tweet_user 事件);error 附带原因,比如受保护的账号。X 上不存在的用户名会出现在 rejected 里。ACCOUNTS 里写不写 @、写个人主页链接、用任意大小写都可以。
  • 读取帖子。 正则匹配任何形如 Solana 地址的字符串;PUMP_ONLY 只保留以 pump 结尾的,顺带去掉帖子里引用的钱包地址和池子地址。很长的帖子可能会被截短,截断处之后的 mint 不在 text 里;帖子的 url 指向完整内容。
  • 链接。 文字里没有 mint 时,RESOLVE_LINKS 从短链接服务的重定向里读出每个 t.co 链接指向哪里,不抓取后面的页面,再在那里找 mint:pump.fun/coin/<mint> 链接、K 线图链接。这要多一次到 X 短链接服务的往返,只发生在文字里没有 mint 的帖子上。如果你关注的账号总是把 mint 写出来,就把它关掉。
  • 多台服务器。 每台服务器都会推送你在它上面关注的账号的每条帖子,并各自统计你的关注数和 socket 数。SERVERS 里不止一台时,posts 保留每条帖子最先到的那份(按 id),丢掉其余的。
  • 每个 mint 只买一次。 同一个 mint 会在几秒内被再次发帖、转帖和引用。mint 在请求发出之前就放进 seen,所以第二次看到它,哪怕是在第一笔买入还在途中时到达,也不会再买。
  • 买入。 一次 Lightspeed 请求,amount 以 SOL 计。Lightspeed 根据自己的缓存路由:还在联合曲线上的币在 pump.fun 上买,已毕业的在 PumpSwap 上买。不是可交易代币的地址会返回错误,什么都不会发出。
  • 报告。 只要有一个服务商接下交易,Lightspeed 就返回:success 表示交易已在路上,submissions 列出每一份副本,任何一份被接受的副本都可能是落地的那份。Solscan 链接指向第一份;要确认成交,盯住全部签名或钱包余额(见交易)。
  • 延迟那一行。 postedAt 是帖子发出的时间,以毫秒计,receivedAt 是我们的服务器收到它的时间,所以 X→stream 是流这一侧的延迟;→you 再加上到你的机器人这一跳,用你的时钟测量。保持服务器时钟同步,否则第二个数字会随时钟一起偏差。

值得调整的设置​

  • BUY_SOL 和 AMOUNTS。 每条帖子一个金额,再按账号单独设金额:对你信任其发射的开发者多买,对喊单账号少买。
  • SLIPPAGE。 被发帖的币在多数买单落地之前就开始涨。滑点太小,人群抢在你前面买入时你的买单会失败;太大,你就要付最初几秒的任何价格。25% 给抢购留出空间;对帖子拉动幅度较小的账号可以调低。
  • TRIGGERS。 关注的账号可以比用来买入的多:不在 TRIGGERS 里的账号只打印、从不买入。转帖算作转帖账号的(它的 user),所以只对你愿意跟着其转帖买入的账号开启转帖。
  • 去重。 seen 在脚本运行期间保证每个 mint 只买一次,重启后就忘了:要跨重启保留,把它写入文件,启动时读回。posts 只用于处理来自多台服务器的同一帖子副本。
  • MAX_AGE_S。 到得晚的帖子(比如重连之后),及时看到它的人都已经买过了;超过这个时长就跳过。
  • PUMP_ONLY。 关掉后,帖子里的任何地址都会尝试买入,包括其他发射平台上的币:Lightspeed 也能路由它们。除非你关注的账号会发非 pump.fun 的币,否则保持开启。
  • TIP、PRIORITY_FEE 和 PROVIDERS。 每份副本都参与竞速;回滚的副本支付自己的优先费,只有落地的那份支付小费,所以预算应放在 TIP 上。最低小费高于 TIP 的服务商不参与竞速:0.001 覆盖除 Node1 外的所有服务商,0.002 覆盖全部(见交易)。使用持久 nonce(请求里加 nonce: true)时,输掉的副本不花任何费用。

退出​

脚本买入后就停在那里。要设目标价、止损和定时,就跟踪这个币的交易并通过 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

一个 socket 同时接 X 和 Telegram​

同一批服务器、同一个密钥也承载 Telegram stream(Telegram 帖子流):一个 socket 可以同时关注 X 账号和 Telegram 聊天,而且 Telegram 的帖子到达时 mint 已经挑好。把它加进上面的脚本,两路信号共用 seen,一个币在 X 上被发帖、又在 Telegram 上被喊单,也只买一次:

// in the "connect" handler, next to subscribe_tweets:
socket.emit("subscribe_telegram", { chats: ["solana_calls"] }, (ack) => console.log(ack.chats ?? ack));

// next to socket.on("tweet", ...):
socket.on("telegram", (p) => {
const mint = p.addresses.solana.find(fresh);
if (mint) buy(mint, `call in ${p.title}: ${p.url ?? ""}`);
});

Telegram 狙击指南里有单独的流版本,带有针对群组和编辑的筛选。

时间花在哪里​

步骤耗时
账号发帖,帖子到达我们的流服务器在 X 一侧;每条帖子都带着它:receivedAt - postedAt
从流服务器到你的机器人一跳网络:连接离你最近的服务器
找到 mint、筛选远低于 1 毫秒;一个 t.co 链接多一次到 X 的往返
从同一城市发出的请求到达 Lightspeed约 1 毫秒
从发出到落地约 50 ms,在每条通道上竞速
  • X 是慢的那一段。 帖子多久到达流服务器由 X 一侧决定,随账号和时刻而变。脚本为每条帖子打印这个数字,你能看到自己关注的账号的实际情况。帖子到达之后的一切都应该在毫秒级完成。
  • 靠近流服务器,也靠近 API。 把机器人跑在一个 Lightspeed 区域:法兰克福、阿姆斯特丹或纽约,并连接大洋同一侧的流服务器。想把流这一侧也压短,就连接多台服务器:每条帖子取最先到的那份。
  • 途中什么都不做。 让 Lightspeed 钱包保持有余额,在帖子和请求之间不查询任何东西:不查余额,不查元数据,不读链。唯一的例外是 t.co 链接,而且只在文字里没有 mint 的帖子上。
  • Socket。 每个密钥在每台服务器上 5 个,与 Telegram stream 共用:同一密钥上的第二个机器人也从这 5 个里占用。
  • 竞速。 Professional 同时竞速全部 8 条 SWQoS 通道和 0 区块通道,约 50 ms 落地(见多服务商竞速);当关注同一账号的每个机器人同时出手时,决定落在哪个 slot(槽位)的就是它。

安全​

  • 先试运行。 在任何 SOL 动之前,用 DRY_RUN = true 看几条帖子。筛选写错,就会买下每条帖子里的每个地址。
  • 备用钱包,小额。 用一个为这个机器人专门创建的 Lightspeed 钱包,里面只放你用来狙击的钱,不要更多。
  • 发帖不等于理由。 账号会被盗,然后贴出一个 mint,把币卖给这条帖子带来的买家;开发者发自己的币也是同样的目的;还有人用同名同代号、mint 不同的仿盘来钓快速机器人。只关注你信任的账号,保持 TRIGGERS 和 PUMP_ONLY 开启。
  • 认用户名,不认显示名。 流按你给的用户名(handle)关注,所以冒充者抄来的显示名不起作用。检查用户名本身:差一个字母就是另一个账号。
  • 密钥只属于你。 永远不要把你的套餐密钥、Lightspeed 密钥或机器人 token 贴进任何聊天或机器人。任何向你索要它们的人,包括自称"客服"的,都是骗子。

Professional 还包含 Developer 的全部内容:多服务商竞速、全部三个区域,以及 Ultra Fast Shred Stream(超快分片流)。见套餐与限额。