InkyWang (Inky)

Yellowstone gRPC 简明教程

InkyWang — Sat, 04 Jan 2025 20:08:55 +0800

我写了一个使用 Solana Yellowstone gRPC (Geyser) 插件快速获取链上数据的简明教程，仍在持续更新中~

👇👇👇

https://github.com/ChainBuff/yellowstone-grpc

适合初学者的 web3js 教程

InkyWang — Wed, 20 Nov 2024 01:35:38 +0800

最近看到社区有不少 Solana 技术的初学者，随即着手写了一个能快速上手的 Solana web3.js 教程，仍在持续更新中~

👇👇👇

https://github.com/ChainBuff/solana-web3js

如何自己写一个聪明钱监控

InkyWang — Fri, 18 Oct 2024 23:18:46 +0800

聪明钱跟单指监听链上胜率高的地址后跟随买入和卖出，本文提供了一个简单的 demo，教你如何监控聪明钱地址。主要内容包括：① 基于 geyser grpc 监听聪明钱包地址与 pump 和 raydium 交互的交易；② 解析交易中的余额变动

聪明钱跟单风险极大，请对自己的钱包负责！

用到的库

import "dotenv/config";
import Client, {CommitmentLevel, SubscribeRequest} from '@triton-one/yellowstone-grpc';
import bs58 from "bs58";
import {Connection, PublicKey, LAMPORTS_PER_SOL} from "@solana/web3.js";
import{ Metadata, deprecated } from "@metaplex-foundation/mpl-token-metadata";

监听包含聪明钱账户的交易

本部分使用 geyser grpc 订阅的方式获取链上与聪明钱地址有关的交易，并再次过滤了一下聪明钱地址与 pump 和 raydium 合约交互的交易（因为此地址可能会有一些其他类型的交易，例如此处未考虑在内的转账交易等）

因为聪明钱的交易频率不高，所以此处所指的聪明钱其实是一个高频交易的 pump 狙击，经常可以做到 +0 和 +1 冲开盘

const addr = ['orcACRJYTFjTeo2pV8TfYRTpmqfoYgbVi9GeANXTCc8'] // 聪明钱地址

const client = new Client('https://grpc.chainbuff.com', undefined, {
    "grpc.max_receive_message_length": 64 * 1024 * 1024, // 64MiB
});

const stream = await client.subscribe();

const streamClosed = new Promise<void>((resolve, reject) => {
    stream.on("error", (error) => {
        reject(error);
        stream.end();
    });
    stream.on("end", () => {
        resolve();
    });
    stream.on("close", () => {
        resolve();
    });
});

stream.on("data", async (data) => {

    if (data.transaction) {
        const accountKeys = data.transaction.transaction.transaction.message.accountKeys.map(ak => bs58.encode(ak));
        if (accountKeys.includes('6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P') || accountKeys.includes('675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8')) {

                // 解析余额变动
            checkBalances(data)
        }
    }
});

// 配置订阅
const request = {
    accounts: {},
    slots: {},
    transactions: {},
    blocks: {},
    blocksMeta: {},
    entry: {},
    commitment: CommitmentLevel.CONFIRMED,
    accountsDataSlice: [],
    ping: undefined,
};

request.transactions.tx = {
    vote: false,
    failed: false,
    signature: undefined,
    accountInclude: addr,
    accountExclude: [],
    accountRequired: [],
};

await new Promise<void>((resolve, reject) => {
    stream.write(request, (err) => {
        if (err === null || err === undefined) {
            resolve();
        } else {
            reject(err);
        }
    });
}).catch((reason) => {
    console.error(reason);
    throw reason;
});

await streamClosed;

这样就监听过滤出了所有聪明钱地址跟 pump 和 raydium 交互的交易，后续通过一个checkBalances函数来解析余额变动注意此处 grpc 订阅链接（https://grpc.chainbuff.com）为社区私有节点，可联系我获取

解析余额变动

先来看一笔 pump 买入的交易示例，主要关注两部分：

solana 余额的变化
聪明钱账户代币余额的变化

可以看到这笔交易实际总花费 2.545549387 个 sol 买入了 80,144,432.9898 个某代币，所以我们的 checkBalances 函数先打印一下这两部分

async function checkBalances (data) {

    // sol balance
    console.log('preBalances', data.transaction.transaction.meta.preBalances)
    console.log('postBalances', data.transaction.transaction.meta.postBalances)

    // token balance
    console.log('preTokenBalances', data.transaction.transaction.meta.preTokenBalances)
    console.log('postTokenBalances', data.transaction.transaction.meta.postTokenBalances)

    console.log('---\n')
}

一个示例的输出应如下，preBalances 和 postBalances 的首个元素为此账户 sol 余额的变动，preTokenBalances 和 postTokenBalances 为此笔交易中账户代币余额的变化，代币余额变化我们只关注 owner 为此聪明钱地址的部分

preBalances [
  '32562846002', '0',
  '65832298',    '281867236367207',
  '2039280',     '501231920',
  '1',           '1141440',
  '1',           '1009200',
  '934087680',   '8530000',
  '731913600',   '1461600',
  '0'
]
postBalances [
  '30017296615', '2039280',
  '77832298',    '281867261431207',
  '2039280',     '3007631920',
  '1',           '1141440',
  '1',           '1009200',
  '934087680',   '8530000',
  '731913600',   '1461600',
  '0'
]
preTokenBalances [
  {
    accountIndex: 4,
    mint: 'CdUVc4xQ3trWvksxyAcu22exniWxVARdrWQTPF6Qpump',
    uiTokenAmount: {
      uiAmount: 982409836.065574,
      decimals: 6,
      amount: '982409836065574',
      uiAmountString: '982409836.065574'
    },
    owner: 'HRAWGWZ86FBGdQCjoG27psb49cbFBRWN3LVwhQ8QXEBp',
    programId: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'
  }
]
postTokenBalances [
  {
    accountIndex: 1,
    mint: 'CdUVc4xQ3trWvksxyAcu22exniWxVARdrWQTPF6Qpump',
    uiTokenAmount: {
      uiAmount: 80144432.9898,
      decimals: 6,
      amount: '80144432989800',
      uiAmountString: '80144432.9898'
    },
    owner: 'orcACRJYTFjTeo2pV8TfYRTpmqfoYgbVi9GeANXTCc8',
    programId: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'
  },
  {
    accountIndex: 4,
    mint: 'CdUVc4xQ3trWvksxyAcu22exniWxVARdrWQTPF6Qpump',
    uiTokenAmount: {
      uiAmount: 902265403.075774,
      decimals: 6,
      amount: '902265403075774',
      uiAmountString: '902265403.075774'
    },
    owner: 'HRAWGWZ86FBGdQCjoG27psb49cbFBRWN3LVwhQ8QXEBp',
    programId: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'
  }
]

所以，完整的checkBalances函数应该如下

interface TokenAccount {
    accountIndex: number;
    mint: string;
    uiTokenAmount: {
        uiAmount: number;
        decimals: number;
        amount: string;
        uiAmountString: string;
    };
    owner: string;
    programId: string;
}

async function checkBalances (data) {

    console.log('slot:', data.transaction.slot);
    console.log(`https://solscan.io/tx/${bs58.encode(data.transaction.transaction.signature)}`);

    // sol balance
    // console.log('preBalances', data.transaction.transaction.meta.preBalances)
    // console.log('postBalances', data.transaction.transaction.meta.postBalances)
    const preBalance = data.transaction.transaction.meta.preBalances[0]
    const postBalance = data.transaction.transaction.meta.postBalances[0]
    const balanceChange = (postBalance - preBalance)/LAMPORTS_PER_SOL
    console.log(balanceChange, 'sol')

    // token balance
    // console.log('preTokenBalances', data.transaction.transaction.meta.preTokenBalances)
    // console.log('postTokenBalances', data.transaction.transaction.meta.postTokenBalances)
    const preTokenBalances: TokenAccount[] = data.transaction.transaction.meta.preTokenBalances
    const postTokenBalances: TokenAccount[] = data.transaction.transaction.meta.postTokenBalances
    for (const postTokenBalance of postTokenBalances) {
        if (addr.includes(postTokenBalance.owner)) {

            const mint = postTokenBalance.mint;
            const postTokenAmount= postTokenBalance.uiTokenAmount.uiAmount;
            const preTokenAmount = preTokenBalances.find(preBalance => preBalance.owner === postTokenBalance.owner && preBalance.mint === mint)?.uiTokenAmount.uiAmount || 0;
            const tokenBalanceChange = postTokenAmount - preTokenAmount;

        // 此处获取代币名称
            let metadataPda = await deprecated.Metadata.getPDA(new PublicKey(mint));
            let metdadataContent =  await Metadata.fromAccountAddress(connection, metadataPda);
            const tokenName = metdadataContent.data.name

            console.log(tokenBalanceChange, tokenName, mint)
        }
    }

    console.log('---\n')
}

关于买入和卖出可以通过 sol 和代币余额的正负来判断，如上面输出是 1 笔买单和 4 笔卖单。

最后，监控到聪明钱后，可以根据自己的策略买入和卖出，也可以将日志消息推送给 telegram 机器人，实时的接收通知消息。

如何自己写一个 pump.fun 狙击枪

InkyWang — Sat, 12 Oct 2024 00:00:14 +0800

更新于 2024/10/11 https://x.com/InkyWang

本文转载自 Buff 社区：https://chainbuff.com

买卖 Pump 平台代币风险极大，请对自己的钱包负责！

Pump 作为 Solana 的发币平台，每天有大量的新流动池被创建，本文提供了一个 demo，教你如何狙击 pump 上的新流动池。主要内容包括：① 基于 geyser grpc 监听 pump 新流动池创建；② 获取买入和卖出新流动池代币所需要的账户；③ 基于 Jito 上链的买入；④ 卖出

用到的库

import "dotenv/config";
import Client, {CommitmentLevel, SubscribeRequest} from '@triton-one/yellowstone-grpc';
import bs58 from "bs58";
import {Connection, PublicKey, Transaction, SystemProgram} from "@solana/web3.js";
import {AnchorProvider, Program, Wallet} from "@coral-xyz/anchor";
import {getKeypairFromEnvironment} from "@solana-developers/helpers";
import fs from "fs";
import {createAssociatedTokenAccountInstruction, getAssociatedTokenAddress} from "@solana/spl-token";
import { BN } from "bn.js";
import axios from "axios";

监听 pump 新流动池创建

为了保证获取链上数据的速度，本部分采用 geyser grpc 订阅的方法获取链上数据。

以下为订阅 pump 新池子的代码，主要步骤为：

创建 grpc 订阅的客户端
订阅交易中包含 pump 账户（6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P）的交易
判断日志中是否有 InitializeMint2 方法
打印一些新池子账户，包括代币 Mint 账户，Bonding Curve 账户和 Associated Bonding Curve 账户，都是后面买入操作需要的

const client = new Client('https://grpc.chainbuff.com', undefined, {
    "grpc.max_receive_message_length": 64 * 1024 * 1024, // 64MiB
});

const stream = await client.subscribe();

const streamClosed = new Promise<void>((resolve, reject) => {
    stream.on("error", (error) => {
        reject(error);
        stream.end();
    });
    stream.on("end", () => {
        resolve();
    });
    stream.on("close", () => {
        resolve();
    });
});

stream.on("data", async (data) => {

    if (data.transaction && data.transaction.transaction.meta.logMessages && data.transaction.transaction.meta.logMessages.some(log => log.includes("Program log: Instruction: InitializeMint2"))) {

        console.log('slot:', data.transaction.slot);
        const accountKeys = data.transaction.transaction.transaction.message.accountKeys.map(ak => bs58.encode(ak));
        console.log('Transaction signature:', bs58.encode(data.transaction.transaction.signature));
        console.log('Mint:', accountKeys[1]);
        console.log('Bonding Curve:', accountKeys[3]);
        console.log('Associated Bonding Curve:', accountKeys[4]);
        console.log('---\n')
    }
});

const request = {
    accounts: {},
    slots: {},
    transactions: {},
    blocks: {},
    blocksMeta: {},
    entry: {},
    commitment: CommitmentLevel.CONFIRMED,
    accountsDataSlice: [],
    ping: undefined,
};
request.transactions.tx = {
    vote: false,
    failed: false,
    signature: undefined,
    accountInclude: ["6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"], // pump
    accountExclude: [],
    accountRequired: [],
};

await new Promise<void>((resolve, reject) => {
    stream.write(request, (err) => {
        if (err === null || err === undefined) {
            resolve();
        } else {
            reject(err);
        }
    });
}).catch((reason) => {
    console.error(reason);
    throw reason;
});

await streamClosed;

输出应如下：

slot: 295023291
Transaction signature: 2HoK765u7TqoYUbDH8FL1MbuKqqV2gtRgoBuw3muoZh72hmowTmgRXxHRJB5fb3nv7D7xp3GwZCAbPJZHEmhCUw1
Mint: 29M9i98AVuWDHV4w1Bfodu9XT7D5y7GpL4zWd134pump
Bonding Curve: HPrDgc4teTeVt1QWAJLMvKJsowgKXKzvUnWKVg3mEVha
Associated Bonding Curve: 9cJRoqJVGr4SXp1TF6UfMG5scTDkh9MdVjvWGnuAGEoh
---

slot: 295023297
Transaction signature: 63DDLJJ9E4gfzmPf8urUWWh3Zx4fGzbRcxCJMq884WBAxxRpHE16e2eWsp9yHJS7MaM3EgvYwBMg6QRaKD2pJxA7
Mint: FxuwwXaZGt41f1wZDBHQ7y282iw7FC7MzEjUn3dcpump
Bonding Curve: 8fiNJQa8a8YWVm3rzkqBMV1xCnDKrfoWmivPpJr5cwRj
Associated Bonding Curve: J9fh1SvH1voMSND9AeR4ZzSAAu4hRfMmRiizNxUUarZB
---

买入

买入操作需要与 pump 合约交互，首先我们需要 pump 合约的的 idl 文件，在此获取：https://chainbuff.com/d/11

观察一笔 pump 的买入交易会发现，在调用 pump 合约的买入指令时，

输入账户 1，2，8，9，10，11，12 是固定的；3，4，5 从刚才监听到的新池子创建交易中已经获取到；6 和 7 分别是 ATA 和我们的买入账户
指令参数分别是买入的代币数量和最大的 sol 花费

因此，买入的交易可以按照下面的方法组装

创建交易
添加 ATA 创建指令
添加 pump 买入指令

const payer = getKeypairFromEnvironment("PUMP_SECRET_KEY"); // 钱包私钥从本地.env文件中获取
console.log(payer.publicKey.toBase58())
const connection = new Connection('http://127.0.0.1:8899', 'confirmed');
const wallet = new Wallet(payer);
const provider = new AnchorProvider(connection, wallet, {
    commitment: 'confirmed',
});
const pumpIDL = JSON.parse(fs.readFileSync('./pump_idl.json', 'utf8')); // 此处需要IDL文件
const pumpProgramId = new PublicKey('6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P');
const pumpProgram = new Program(pumpIDL, pumpProgramId, provider);

// 创建交易
let transaction = new Transaction();

// 添加ATA创建指令
transaction.add(
    createAssociatedTokenAccountInstruction(
        payer.publicKey,
        associatedUser,
        payer.publicKey,
        new PublicKey(accountKeys[1]),
    )
)

// 获取ATA
const associatedUser = await getAssociatedTokenAddress(new PublicKey(accountKeys[1]), payer.publicKey, false);

// 添加pump买入指令
const amount = 17231 * 1e6;
const solAmount = 0.001 * 1e9;
transaction.add(
    await pumpProgram.methods
        .buy(new BN(amount.toString()), new BN(solAmount.toString()))
        .accounts({
            global: new PublicKey('4wTV1YmiEkRvAtNtsSGPtUrqRYQMe5SKy2uB4Jjaxnjf'),
            feeRecipient: new PublicKey('CebN5WGQ4jvEPvsVU4EoHEpgzq1VV7AbicfhtW4xC9iM'),
            mint: new PublicKey(accountKeys[1]),
            bondingCurve: new PublicKey(accountKeys[3]),
            associatedBondingCurve: new PublicKey(accountKeys[4]),
            associatedUser: associatedUser,
            user: payer.publicKey,
            systemProgram: new PublicKey('11111111111111111111111111111111'),
            tokenProgram: new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'),
            rent: new PublicKey('SysvarRent111111111111111111111111111111111'),
            eventAuthority: new PublicKey('Ce6TQqeHC9p8KetsN6JsjHK7UTZk7nasjjnr7XxXp9F1'),
            program: new PublicKey('6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P')
        })
        .instruction()
);

至此，pump 新池子买入交易的组装其实就已经完成，通过对交易进行签名后，就可以正常发送。

此处可以在自己的 rpc 上模拟一下交易指令是否组装正确

const { blockhash } = await connection.getLatestBlockhash();
transaction.recentBlockhash = blockhash;
transaction.feePayer = payer.publicKey;

const signedTransaction = await wallet.signTransaction(transaction);

// simulate
const simulationResult = await connection.simulateTransaction(signedTransaction);
console.log(JSON.stringify(simulationResult));

输出如下，没有报错

{"context":{"apiVersion":"2.0.3","slot":295026886},"value":{"accounts":null,"err":null,"innerInstructions":null,"logs":["Program ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL invoke [1]","Program log: Create","Program TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA invoke [2]","Program log: Instruction: GetAccountDataSize","Program TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA consumed 1569 of 382633 compute units","Program return: TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA pQAAAAAAAAA=","Program TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA success","Program 11111111111111111111111111111111 invoke [2]","Program 11111111111111111111111111111111 success","Program log: Initialize the associated token account","Program TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA invoke [2]","Program log: Instruction: InitializeImmutableOwner","Program log: Please upgrade to SPL Token 2022 for immutable owner support","Program TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA consumed 1405 of 376046 compute units","Program TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA success","Program TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA invoke [2]","Program log: Instruction: InitializeAccount3","Program TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA consumed 4188 of 372164 compute units","Program TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA success","Program ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL consumed 32307 of 400000 compute units","Program ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL success","Program 6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P invoke [1]","Program log: Instruction: Buy","Program TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA invoke [2]","Program log: Instruction: Transfer","Program TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA consumed 4645 of 347555 compute units","Program TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA success","Program 11111111111111111111111111111111 invoke [2]","Program 11111111111111111111111111111111 success","Program 11111111111111111111111111111111 invoke [2]","Program 11111111111111111111111111111111 success","Program 6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P invoke [2]","Program 6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P consumed 2003 of 335467 compute units","Program 6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P success","Program data: vdt/007mYe5mbiGblezgN2DrBjE9HC+Ww3+vh6e5SKBBfQ/CypN13zNdCAAAAAAAwDEMAwQAAAABDEX33hExn+8SWHycXRZ2xxy10o60OnPy0sawSA80E8GrRAlnAAAAADOdYXMHAAAAQV1OEOGSAwAz8T13AAAAAEHFO8RPlAIA","Program 6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P consumed 35954 of 367693 compute units","Program 6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P success"],"replacementBlockhash":null,"returnData":null,"unitsConsumed":68261}}

Jito 发送交易

使用 Jito 上链只需要①在交易的最后添加一笔给 jito tip 账户转账的指令，用于支付小费；②将交易发给 Jito 的 block engine

具体代码如下

// 添加支付小费指令
transaction.add(SystemProgram.transfer({
    fromPubkey: wallet.publicKey,
    toPubkey: new PublicKey('DttWaMuVvTiduZRnguLF7jNxTgiMBZ1hyAumKUiL2KRL'),
    lamports: 0.001*1e9,
}))

const { blockhash } = await connection.getLatestBlockhash();
transaction.recentBlockhash = blockhash;
transaction.feePayer = payer.publicKey;

const signedTransaction = await wallet.signTransaction(transaction);

// 发送交易
const serializedTransaction = signedTransaction.serialize();
const base58Transaction = bs58.encode(serializedTransaction);

const bundle_data = {
    jsonrpc: "2.0",
    id: 1,
    method: "sendBundle",
    params: [[base58Transaction]]
};
const bundle_resp = await axios.post(`https://frankfurt.mainnet.block-engine.jito.wtf/api/v1/bundles`, bundle_data, {
    headers: {
        'Content-Type': 'application/json'
    }
});
const bundle_id = bundle_resp.data.result
console.log(`sent to frankfurt, bundle id: ${bundle_id}`)

成功的买入示例交易可以在此查看：https://solscan.io/tx/3SsYxUY5F9w2Wk6APMSEGbSz7Yw13tYrRax2PECk1yF6XsTXVWuG2jQLwxCaJxdRN9MhewwZGcSpv58qMwdmLyie

卖出

观察一笔卖出的交易指令会发现，输入账户与买入相同，指令参数变为了卖出的代币数量和获得的最少 sol 数量。可参照之前的买入操作写自己的卖出策略。

卖出策略因人而异，不仅要保证自己获取链上数据的速度和上链的速度，要买的快，还要卖的好。但要问我哪个更重要，我想说，买的快不如卖的好。

最后，geyser grpc 订阅服务对于个人来说比较昂贵，可联系我获取社区节点的 geyser 服务，限制使用人数，无频率限制。

Jito ShredStream 数据接口配置

InkyWang — Tue, 08 Oct 2024 01:45:27 +0800

Shred作为 solana 网络中数据传播的最小单元，以最快的速度在网络中以 udp 的形式传播。通过拼装解析 Shred 数据流可以使得交易者抢占先机。本文教你如何开启基于 Jito 的 ShredStream，更详细的教程请参与Jito 文档

申请授权 pubkey

在此处填写 jito 提供的表单注册授权 pubkey，此账户中不应有任何的资金，提交时只需要提交 pubkey 即可。

防火墙放行 jito 的 ip

此处放行了 jito 所有区域的 ip，可以在此处查看。

ufw allow from 74.118.140.240
ufw allow from 202.8.8.174
ufw allow from 145.40.93.84
ufw allow from 145.40.93.41
ufw allow from 141.98.216.96
ufw allow from 64.130.48.56
ufw allow from 64.130.53.8
ufw allow from 64.130.53.57
ufw allow from 202.8.9.160
ufw allow from 202.8.9.19

下载配置 jito-shredstream-proxy

查询自己的 tvu 端口

bash -c "$(curl -fsSL https://raw.githubusercontent.com/jito-labs/shredstream-proxy/master/scripts/get_tvu_port.sh)"

开启 jito-shredstream 数据流服务，默认接收到的 shreds 数据在本地 udp 20000 端口

git clone https://github.com/jito-labs/shredstream-proxy.git --recurse-submodules

RUST_LOG=info cargo run --release --bin jito-shredstream-proxy -- shredstream \
    --block-engine-url https://frankfurt.mainnet.block-engine.jito.wtf \
    --auth-keypair /root/xyz4g33hXuR84saNFe3tRgcu9NbB8AeqX5YMcLetMek.json \
    --desired-regions amsterdam,frankfurt \
    --dest-ip-ports 127.0.0.1:8001

--block-engine-url 为节点最近的 jito 区块引擎地址
--auth-keypair 为被授权的私钥
--desired-regions 为想要接收 shreds 的区域
--dest-ip-ports 为要绑定的接收 shreds 的 IP 和端口，即 tvu 端口

一个简单的示例

use pcap::{Capture, Device};
use solana_ledger::shred::Shred;
use std::error::Error;

fn main() -> Result<(), Box<dyn Error>> {
    // 获取网络设备列表
    let devices = Device::list()?;
    // 打印可用设备列表
    // println!("可用网络设备:");
    for (i, device) in devices.iter().enumerate() {
        println!("{}. {}", i, device.name);
    }
    // 选择要监听的设备（这里假设使用第一个设备，你可以根据需要修改）
    let device = &devices[0];
    // 创建捕获器
    let mut cap = Capture::from_device(device.name.as_str())?
        .promisc(true)
        .snaplen(65535)
        .open()?;
    // 设置过滤器只捕获UDP 20000端口的数据包
    cap.filter("udp port 20000", true)?;
    println!("开始监听 {} 上的UDP 20000端口...", device.name);
    while let Ok(packet) = cap.next_packet() {
        // UDP头部长度为8字节，我们需要跳过它
        let payload = &packet.data[42..]; // 跳过以太网头(14字节) + IP头(20字节) + UDP头(8字节)
        match Shred::new_from_serialized_shred(payload.to_vec()) {
            Ok(shred) => {
                println!("接收到Shred");
                println!("ID: {:?}", shred.id());
                println!("Slot: {}", shred.slot());
                println!("Index: {}", shred.index());
                println!("数据完整: {}", shred.data_complete());
                if shred.is_data() {
                    println!("类型: 数据Shred");
                    let payload = shred.payload();
                    println!("payload长度: {}", payload.len());

                } else {
                    println!("类型: 编码Shred");
                }
                println!("------------------------");
            },
            Err(e) => println!("解析Shred失败: {:?}", e),
        }
    }
    Ok(())
}

cargo run

Yellowstone geyser 插件配置

InkyWang — Tue, 08 Oct 2024 01:04:44 +0800

更新于 2024/10/08 https://x.com/InkyWang

Geyser 插件数据流服务支持数据订阅和过滤，相比与普通的 rpc 请求可以更快速的获取链上数据。本文教你如何在自建 rpc 上安装 geyser 插件，结合之前如何运行一个 Solana RPC 节点教程，只需要下载和配置 geyser 文件和在启动参数中添加 geyser 配置文件路径。

下载 geyser

根据自己 solana-cli 的版本在官方仓库找到对应版本，此处的 solana-cli 版本为 1.8.15

wget https://github.com/rpcpool/yellowstone-grpc/releases/download/v1.15.3%2Bsolana.1.18.15/yellowstone-grpc-geyser-release-x86_64-unknown-linux-gnu.tar.bz2

apt-get install bzip2

tar -xvjf yellowstone-grpc-geyser-release-x86_64-unknown-linux-gnu.tar.bz2

配置 geyser

vim yellowstone-config.json

{
    "libpath": "/root/yellowstone-grpc-geyser-release/lib/libyellowstone_grpc_geyser.so",
    "log": {
        "level": "info"
    },
    "grpc": {
        "address": "0.0.0.0:10001",
        "snapshot_plugin_channel_capacity": null,
        "snapshot_client_channel_capacity": "500_000_000",
        "channel_capacity": "5_000_000",
        "unary_concurrency_limit": 5000,
        "unary_disabled": false,
        "max_decoding_message_size": "16_777_216"
    },
    "prometheus": {
        "address": "0.0.0.0:8999"
    },
    "block_fail_action": "log"
}

启用 geyser

参照先前的 solana rpc 节点启动脚本，需要在脚本中添加 geyser 配置文件的位置

--geyser-plugin-config /root/yellowstone-config.json

完整的启动脚本如下

#!/bin/bash

exec solana-validator \
    --geyser-plugin-config /root/yellowstone-config.json \
    --ledger /root/sol/ledger \
    --accounts /root/sol/accounts \
    --identity /root/validator-keypair.json \
    --known-validator 7Np41oeYqPefeNQEHSv1UDhYrehxin3NStELsSKCT4K2 \
    --known-validator GdnSyH3YtwcxFvQrVVJMm1JhTS4QVX7MFsX56uJLUfiZ \
    --known-validator DE1bawNcRJB9rVm3buyMVfr8mBEoyyu73NBovf2oXJsJ \
    --known-validator CakcnaRDHka2gXyfbEd2d3xsvkJkqsLw2akB3zsN1D2S \
    --entrypoint entrypoint.mainnet-beta.solana.com:8001 \
    --entrypoint entrypoint2.mainnet-beta.solana.com:8001 \
    --entrypoint entrypoint3.mainnet-beta.solana.com:8001 \
    --entrypoint entrypoint4.mainnet-beta.solana.com:8001 \
    --entrypoint entrypoint5.mainnet-beta.solana.com:8001 \
    --expected-genesis-hash 5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpKuc147dw2N9d \
    --full-rpc-api \
    --no-voting \
    --private-rpc \
    --rpc-port 8899 \
    --gossip-port 8001 \
    --dynamic-port-range 8000-8020 \
    --wal-recovery-mode skip_any_corrupted_record \
    --limit-ledger-size \
    --account-index program-id \
    --account-index spl-token-mint \
    --account-index spl-token-owner \
    --enable-rpc-transaction-history \
    --enable-cpi-and-log-storage \
    --init-complete-file /root/init-completed \
    --log /root/solana-rpc.log

使用教程

https://docs.triton.one/project-yellowstone/dragons-mouth-grpc-subscriptions https://github.com/rpcpool/yellowstone-grpc/tree/master/examples

如何监控 solana raydium v4 新流动性池创建

InkyWang — Sat, 21 Sep 2024 16:09:52 +0800

更新于 2024/09/18 https://x.com/InkyWang

本教程实现了监听 solana 链上 raydium dex v4 的新流动性池创建，通过解析交易获得了配对代币名称和数量，可以按照类似方法获得池子更多信息。

如有错误，欢迎指正。

基本思路

监听 Raydium Liquidity Pool V4 的 log，过滤出包含 initialize2 方法的交易
解析交易，获得流动池信息

# 用到的库
const solanaWeb3 = require('@solana/web3.js');
const splToken = require('@solana/spl-token');
const { Metadata, deprecated } = require('@metaplex-foundation/mpl-token-metadata');
const bs58 = require('bs58');
const { struct, u8, nu64 } = require('@solana/buffer-layout');

1. 监听 Raydium Liquidity Pool V4 的 log

const connection = new solanaWeb3.Connection('{rpc}', 'confirmed'); // {rpc}处填写为自己的rpc
const raydiumV4Address = '675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8'
const raydiumV4PublicKey = new solanaWeb3.PublicKey('675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8');

connection.onLogs(
        raydiumV4PublicKey,
        ({ logs, err, signature }) => {
            if (err) return;

            if (logs && logs.some(log => log.includes("initialize2"))) {
                console.log("Signature for 'initialize2':", signature);
            }
        },
        "confirmed"
    );

这样我们就可以获取到所有刚创建池子的交易，输出应该如下：

Monitoring logs for program: 675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8
Signature for 'initialize2': 2YY7BM9NMH8fbSgNsy6YhWg6hEvnbpau4kNdmTXYcqs7UHo6NxY8MuZZH7qJke71vuNvmQmUUDA8LdkdgqYyrFP9

2. 解析交易

在 solscan 里可以看到交易2YY7BM9NMH8fbSgNsy6YhWg6hEvnbpau4kNdmTXYcqs7UHo6NxY8MuZZH7qJke71vuNvmQmUUDA8LdkdgqYyrFP9的详细信息。

找到 Instruction Details 部分，找到与 Raydium Liquidity Pool V4 交互的指令部分，如下图：

在这里，我们关注两部分：一个 Input Accounts，可以获得代币信息；另一个是 Instruction Data 可以获得数量信息

# 解析交易
const tx = await connection.getParsedTransaction(
        signature,
        {
            maxSupportedTransactionVersion: 0,
            commitment: 'confirmed'
        });

# 获取Input Accounts
const accounts = tx?.transaction.message.instructions.find(ix => ix.programId.toBase58() === raydiumV4Address).accounts;

# 获取池子地址和配对的代币地址，index分别为4，8和9
const LPIndex = 4;
const tokenAIndex = 8;
const tokenBIndex = 9;

const LPAccount = accounts[LPIndex]
const tokenAAccount = accounts[tokenAIndex];
const tokenBAccount = accounts[tokenBIndex];

# 获取两种代币的名字和精度
async function fetchTokenInfo(tokenPublicKey){

    const mintAddress = new solanaWeb3.PublicKey(tokenPublicKey);
    const mintInfo = await splToken.getMint(connection, mintAddress);
    // console.log("Decimals: " + mintInfo.decimals);

    let metadataPda = await deprecated.Metadata.getPDA(mintAddress);
    let metdadataContent =  await Metadata.fromAccountAddress(connection, metadataPda);

    return [metdadataContent.data.name, mintInfo.decimals];
}

const tokenA = await fetchTokenInfo(tokenAAccount.toBase58());
const tokenB = await fetchTokenInfo(tokenBAccount.toBase58());

# 解码指令数据
const instructionData = bs58.decode(tx?.transaction.message.instructions.find(ix => ix.programId.toBase58() === raydiumV4Address).data);
const RAYDIUM_INSTRUCTION_LAYOUT = struct([
        u8('discriminator'),
        u8('nonce'),
        nu64('opentime'),
        nu64('initPcAmount'),
        nu64('initCoinAmount')
    ]);
const decodedInstruction = RAYDIUM_INSTRUCTION_LAYOUT.decode(instructionData);

opentime 字段应该是开盘时间，有的是 0（立即开盘），有的是 linux 时间戳，还在观察

最后打印一下结果

console.log(`TX: https://solscan.io/tx/${txId}`);
const displayData = [
    { "Token": tokenA[0].replace(/\x00/g, ''), "Account Public Key": tokenAAccount.toBase58(), "Amount": decodedInstruction.initCoinAmount/Math.pow(10, tokenA[1]) },
    { "Token": tokenB[0].replace(/\x00/g, ''), "Account Public Key": tokenBAccount.toBase58(), "Amount": decodedInstruction.initPcAmount/Math.pow(10, tokenB[1]) }
];
console.log(`New LP: ${LPAccount.toBase58()}`)
if(decodedInstruction.opentime !== 0) {
    const opentime = moment.unix(decodedInstruction.opentime).tz('Asia/Shanghai').format('YYYY-MM-DD HH:mm:ss');
    console.log(`opentime: ${opentime}`)
}
console.table(displayData);

完整代码

const solanaWeb3 = require('@solana/web3.js');
const splToken = require('@solana/spl-token');
const { Metadata, deprecated } = require('@metaplex-foundation/mpl-token-metadata');
const bs58 = require('bs58');
const { struct, u8, nu64 } = require('@solana/buffer-layout');
// const moment = require('moment-timezone');

const connection = new solanaWeb3.Connection('http://45.250.254.126:1256', 'confirmed');
const raydiumV4Address = '675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8'
const raydiumV4PublicKey = new solanaWeb3.PublicKey('675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8');

async function main() {

    console.log("Monitoring logs for program:", raydiumV4PublicKey.toString());

    connection.onLogs(
        raydiumV4PublicKey,
        ({ logs, err, signature }) => {
            if (err) return;

            if (logs && logs.some(log => log.includes("initialize2"))) {
                // console.log("Signature for 'initialize2':", signature);
                fetchPoolInfo(signature, connection);
            }
        },
        "confirmed"
    );

    // fetchPoolInfo('2isUeFKrgwpfh6kGKjaQ6SrrjxAHycyxqnvaDbR8EVFLo4R2jadxGp8o4gsHkBZgru2U3DRDRHggttfmbNj37gun', connection);
}

async function fetchPoolInfo(signature, connection) {
    const tx = await connection.getParsedTransaction(
        signature,
        {
            maxSupportedTransactionVersion: 0,
            commitment: 'confirmed'
        });

    const accounts = tx?.transaction.message.instructions.find(ix => ix.programId.toBase58() === raydiumV4Address).accounts;

    if (!accounts) {
        console.log("No accounts found in the transaction.");
        return;
    }

    const LPIndex = 4;
    const tokenAIndex = 8;
    const tokenBIndex = 9;

    const LPAccount = accounts[LPIndex]
    const tokenAAccount = accounts[tokenAIndex];
    const tokenBAccount = accounts[tokenBIndex];

    const tokenA = await fetchTokenInfo(tokenAAccount.toBase58());
    const tokenB = await fetchTokenInfo(tokenBAccount.toBase58());

    const instructionData = bs58.decode(tx?.transaction.message.instructions.find(ix => ix.programId.toBase58() === raydiumV4Address).data);
    // console.log(instructionData)
    const RAYDIUM_INSTRUCTION_LAYOUT = struct([
        u8('discriminator'),
        u8('nonce'),
        nu64('opentime'),
        nu64('initPcAmount'),
        nu64('initCoinAmount')
    ]);

    const decodedInstruction = RAYDIUM_INSTRUCTION_LAYOUT.decode(instructionData);
    // console.log('Decoded instruction:', {
    //     discriminator: {
    //         type: 'u8',
    //         data: decodedInstruction.discriminator
    //     },
    //     nonce: {
    //         type: 'u8',
    //         data: decodedInstruction.nonce
    //     },
    //     opentime: {
    //         type: 'u64',
    //         data: decodedInstruction.opentime
    //     },
    //     initPcAmount: {
    //         type: 'u64',
    //         data: decodedInstruction.initPcAmount.toString()
    //     },
    //     initCoinAmount: {
    //         type: 'u64',
    //         data: decodedInstruction.initCoinAmount.toString()
    //     }
    // });

    console.log(`TX: https://solscan.io/tx/${signature}`);
    const displayData = [
        { "Token": tokenA[0].replace(/\x00/g, ''), "Account Public Key": tokenAAccount.toBase58(), "Amount": decodedInstruction.initCoinAmount/Math.pow(10, tokenA[1]) },
        { "Token": tokenB[0].replace(/\x00/g, ''), "Account Public Key": tokenBAccount.toBase58(), "Amount": decodedInstruction.initPcAmount/Math.pow(10, tokenB[1]) }
    ];
    console.log(`New LP: ${LPAccount.toBase58()}`)
    // if(decodedInstruction.opentime !== 0) {
    //     const opentime = moment.unix(decodedInstruction.opentime).tz('Asia/Shanghai').format('YYYY-MM-DD HH:mm:ss');
    //     console.log(`opentime: ${opentime}`)
    // }
    console.table(displayData);
}

async function fetchTokenInfo(tokenPublicKey){

    const mintAddress = new solanaWeb3.PublicKey(tokenPublicKey);
    const mintInfo = await splToken.getMint(connection, mintAddress);
    // console.log("Decimals: " + mintInfo.decimals);
    // console.log("Supply: " + mintInfo.supply);

    let metadataPda = await deprecated.Metadata.getPDA(mintAddress);
    let metdadataContent =  await Metadata.fromAccountAddress(connection, metadataPda);

    return [metdadataContent.data.name, mintInfo.decimals];
}

main().catch(console.error);
// https://dexscreener.com/?rankBy=pairAge&order=asc&chainIds=solana&dexIds=raydium

如何运行一个 Solana RPC 节点

InkyWang — Wed, 07 Aug 2024 21:00:52 +0800

2024/08/07更新

根据官方要求，Solana RPC 节点至少需要 512GB 内存。实际测试下来，在开启 account-index 参数后，v1.18+ 版本节点稳定时需要 330GB 左右内存，偶尔峰值会到 430G（推荐 512G，不然可能会内存溢出），而 v1.17+ 版本则需要近 1TB 内存。

挂载磁盘

官方推荐机器至少 3 个 NVMe 盘，一个系统盘，一个存账户数据，一个存账本数据。除系统盘外，每个硬盘推荐使用 2T 的存储空间。以下为创建项目目录和挂载磁盘的命令：

mkdir /root/sol
mkdir /root/sol/accounts
mkdir /root/sol/ledger
mkdir /root/sol/bin

# n + e
fdisk /dev/nvme0n1
fdisk /dev/nvme1n1

mkfs -t ext4 /dev/nvme0n1
mkfs -t ext4 /dev/nvme1n1

mount /dev/nvme0n1 /root/sol/ledger
mount /dev/nvme1n1 /root/sol/accounts

vim /etc/fstab
/dev/nvme0n1 /root/sol/ledger ext4 defaults 0 0
/dev/nvme1n1 /root/sol/accounts ext4 defaults 0 0

将 cpu 设置为 performance 模式

Solana 节点对 cpu 主频要求较高，推荐使用高频 cpu 并将性能设置为 performance 模式。

apt install linux-tools-common linux-tools-$(uname -r)

cpupower frequency-info

cpupower frequency-set --governor performance

watch "grep 'cpu MHz' /proc/cpuinfo"

下载 solana-cli

# sh -c "$(curl -sSfL https://release.solana.com/stable/install)"
# 使用v1.18+版本，内存占用少
sh -c "$(curl -sSfL https://release.solana.com/v1.18.15/install)"

vim /root/.bashrc
export PATH="/root/.local/share/solana/install/active_release/bin:$PATH"
source /root/.bashrc

solana --version

创建验证者私钥

solana-keygen new -o validator-keypair.json

系统调优

修改/etc/sysctl.conf

vim /etc/sysctl.conf

添加如下

# Increase UDP buffer sizes
net.core.rmem_default = 134217728
net.core.rmem_max = 134217728
net.core.wmem_default = 134217728
net.core.wmem_max = 134217728

# Increase memory mapped files limit
vm.max_map_count = 1000000

# Increase number of allowed open file descriptors
fs.nr_open = 1000000

sysctl -p

修改/etc/systemd/system.conf

vim /etc/systemd/system.conf

添加如下

DefaultLimitNOFILE=1000000

systemctl daemon-reload

修改/etc/security/limits.conf

vim /etc/security/limits.conf

添加如下

# Increase process file descriptor count limit
* - nofile 1000000

ulimit -n 1000000 # 手动设置一下，不然需要重启机器

开启防火墙

sudo ufw allow 22
sudo ufw allow 8000:8020/tcp
sudo ufw allow 8000:8020/udp
sudo ufw allow 8899 # http 端口
sudo ufw allow 8900 # websocket 端口

sudo ufw enable
sudo ufw status

创建启动脚本和服务

vim /root/sol/bin/validator.sh

添加如下

#!/bin/bash

exec solana-validator \
    --ledger /root/sol/ledger \
    --accounts /root/sol/accounts \
    --identity /root/validator-keypair.json \
    --known-validator 7Np41oeYqPefeNQEHSv1UDhYrehxin3NStELsSKCT4K2 \
    --known-validator GdnSyH3YtwcxFvQrVVJMm1JhTS4QVX7MFsX56uJLUfiZ \
    --known-validator DE1bawNcRJB9rVm3buyMVfr8mBEoyyu73NBovf2oXJsJ \
    --known-validator CakcnaRDHka2gXyfbEd2d3xsvkJkqsLw2akB3zsN1D2S \
    --entrypoint entrypoint.mainnet-beta.solana.com:8001 \
    --entrypoint entrypoint2.mainnet-beta.solana.com:8001 \
    --entrypoint entrypoint3.mainnet-beta.solana.com:8001 \
    --entrypoint entrypoint4.mainnet-beta.solana.com:8001 \
    --entrypoint entrypoint5.mainnet-beta.solana.com:8001 \
    --expected-genesis-hash 5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpKuc147dw2N9d \
    --full-rpc-api \
    --no-voting \
    --private-rpc \
    --rpc-port 8899 \
    --gossip-port 8001 \
    --dynamic-port-range 8000-8020 \
    --wal-recovery-mode skip_any_corrupted_record \
    --limit-ledger-size \
    --account-index program-id \
    --account-index spl-token-mint \
    --account-index spl-token-owner \
    --enable-rpc-transaction-history \
    --enable-cpi-and-log-storage \
    --init-complete-file /root/init-completed \
    --log /root/solana-rpc.log

    # 以下参数按需选择添加
    # 务必了解每个参数的功能
    # --rpc-bind-address 0.0.0.0 \
    # --tpu-enable-udp \
    # --only-known-rpc \
    # --rpc-send-default-max-retries 0 \
    # --rpc-send-service-max-retries 0 \
    # --rpc-send-retry-ms 2000 \
    # --minimal-snapshot-download-speed 1073741824 \
    # --maximum-snapshot-download-abort 3 \
    # --rpc-send-leader-count 1500 \
    # --private-rpc \
    # --accounts-index-memory-limit-mb 1024000 \
    # --limit-ledger-size 50000000 \
    # --minimal-snapshot-download-speed 1073741824 \

chmod +x /root/sol/bin/validator.sh

vim /etc/systemd/system/sol.service

添加如下

[Unit]
Description=Solana Validator
After=network.target
StartLimitIntervalSec=0

[Service]
Type=simple
Restart=always
RestartSec=1
User=root
LimitNOFILE=1000000
LogRateLimitIntervalSec=0
Environment="PATH=/bin:/usr/bin:/root/.local/share/solana/install/active_release/bin"
ExecStart=/root/sol/bin/validator.sh

[Install]
WantedBy=multi-user.target

# 系统服务相关命令
systemctl start sol
systemctl status sol
systemctl stop sol
systemctl restart sol
systemctl daemon-reload

# 查看服务是否正常运行
tail -f /root/solana-rpc.log
journalctl -u sol -f --no-hostname -o cat
ps aux | grep solana-validator

查看同步进度

solana-keygen pubkey /root/validator-keypair.json
solana gossip | grep {pubkey}
solana catchup {pubkey}

如果机器配置和网络没问题的话，应该可以看到在慢慢追块。

InkyWang (Inky)

Yellowstone gRPC 简明教程

适合初学者的 web3js 教程

如何自己写一个聪明钱监控

用到的库

监听包含聪明钱账户的交易

解析余额变动

如何自己写一个 pump.fun 狙击枪

用到的库

监听 pump 新流动池创建

买入

Jito 发送交易

卖出

Jito ShredStream 数据接口配置

申请授权 pubkey

防火墙放行 jito 的 ip

下载配置 jito-shredstream-proxy

一个简单的示例

Yellowstone geyser 插件配置

下载 geyser

配置 geyser

启用 geyser

使用教程

如何监控 solana raydium v4 新流动性池创建

基本思路

1. 监听 Raydium Liquidity Pool V4 的 log

2. 解析交易

完整代码

如何运行一个 Solana RPC 节点

挂载磁盘

将 cpu 设置为 performance 模式

下载 solana-cli

创建验证者私钥

系统调优

开启防火墙

创建启动脚本和服务

查看同步进度

参考