构建 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)`);
运行
- 填好顶部配置。 你的套餐密钥、控制台上一台流服务器的地址、要关注的账号,以及你的 Lightspeed 密钥。
- 试运行。
DRY_RUN = true时,它会连接,在每个账号上线时打印出来(或打印无法关注的原因),然后打印每条帖子:谁发的、到达流服务器和到达你各用了多久,以及它本会发出的买单。让它跑过几条帖子,检查它本会买些什么。 - 正式运行。
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(超快分片流)。见套餐与限额。