sol_parser_sdk/instr/
utils.rs

1//! 指令解析通用工具函数
2
3use crate::core::events::EventMetadata;
4use solana_sdk::{pubkey::Pubkey, signature::Signature};
5use yellowstone_grpc_proto::prelude::{Transaction, TransactionStatusMeta};
6
7/// 创建事件元数据的通用函数
8pub fn create_metadata(
9    signature: Signature,
10    slot: u64,
11    tx_index: u64,
12    block_time_us: i64,
13    grpc_recv_us: i64,
14) -> EventMetadata {
15    EventMetadata { signature, slot, tx_index, block_time_us, grpc_recv_us, recent_blockhash: None }
16}
17
18/// 创建事件元数据的兼容性函数（用于指令解析）
19#[inline(always)]
20pub fn create_metadata_simple(
21    signature: Signature,
22    slot: u64,
23    tx_index: u64,
24    block_time_us: Option<i64>,
25    _program_id: Pubkey,
26) -> EventMetadata {
27    let current_time = now_us();
28
29    EventMetadata {
30        signature,
31        slot,
32        tx_index,
33        block_time_us: block_time_us.unwrap_or(0),
34        grpc_recv_us: current_time,
35        recent_blockhash: None,
36    }
37}
38
39/// 从指令数据中读取 u64（小端序）- SIMD 优化
40#[inline(always)]
41pub fn read_u64_le(data: &[u8], offset: usize) -> Option<u64> {
42    data.get(offset..offset + 8).map(|slice| u64::from_le_bytes(slice.try_into().unwrap()))
43}
44
45/// 从指令数据中读取 u32（小端序）- SIMD 优化
46#[inline(always)]
47pub fn read_u32_le(data: &[u8], offset: usize) -> Option<u32> {
48    data.get(offset..offset + 4).map(|slice| u32::from_le_bytes(slice.try_into().unwrap()))
49}
50
51/// 从指令数据中读取 u16（小端序）- SIMD 优化
52#[inline(always)]
53pub fn read_u16_le(data: &[u8], offset: usize) -> Option<u16> {
54    data.get(offset..offset + 2).map(|slice| u16::from_le_bytes(slice.try_into().unwrap()))
55}
56
57/// 从指令数据中读取 u8
58#[inline(always)]
59pub fn read_u8(data: &[u8], offset: usize) -> Option<u8> {
60    data.get(offset).copied()
61}
62
63/// 从指令数据中读取 i32（小端序）- SIMD 优化
64#[inline(always)]
65pub fn read_i32_le(data: &[u8], offset: usize) -> Option<i32> {
66    data.get(offset..offset + 4).map(|slice| i32::from_le_bytes(slice.try_into().unwrap()))
67}
68
69/// 从指令数据中读取 u128（小端序）- SIMD 优化
70#[inline(always)]
71pub fn read_u128_le(data: &[u8], offset: usize) -> Option<u128> {
72    data.get(offset..offset + 16).map(|slice| u128::from_le_bytes(slice.try_into().unwrap()))
73}
74
75/// 从指令数据中读取布尔值
76#[inline(always)]
77pub fn read_bool(data: &[u8], offset: usize) -> Option<bool> {
78    data.get(offset).map(|&b| b != 0)
79}
80
81/// IDL 自定义类型 `OptionBool`（Anchor：`struct { bool }`）在 **指令参数** 中与 `bool` 相同，Borsh 仅占 **1 字节**。
82/// 勿与 Rust `Option<bool>` 的 Borsh 编码（discriminator + inner，共 2 字节）混淆。
83#[inline(always)]
84pub fn read_option_bool_idl(data: &[u8], offset: usize) -> Option<bool> {
85    match data.get(offset).copied()? {
86        0 => Some(false),
87        1 => Some(true),
88        _ => None,
89    }
90}
91
92/// 从指令数据中读取公钥 - SIMD 优化
93#[inline(always)]
94pub fn read_pubkey(data: &[u8], offset: usize) -> Option<Pubkey> {
95    data.get(offset..offset + 32).and_then(|slice| Pubkey::try_from(slice).ok())
96}
97
98/// 从账户列表中获取账户
99#[inline(always)]
100pub fn get_account(accounts: &[Pubkey], index: usize) -> Option<Pubkey> {
101    accounts.get(index).copied()
102}
103
104/// 计算滑点基点
105pub fn calculate_slippage_bps(amount_in: u64, amount_out_min: u64) -> u16 {
106    if amount_in == 0 {
107        return 0;
108    }
109
110    // 简化的滑点计算
111    let slippage = ((amount_in.saturating_sub(amount_out_min)) * 10000) / amount_in;
112    slippage.min(10000) as u16
113}
114
115/// 计算价格影响基点
116pub fn calculate_price_impact_bps(_amount_in: u64, amount_out: u64, expected_out: u64) -> u16 {
117    if expected_out == 0 {
118        return 0;
119    }
120
121    let impact = ((expected_out.saturating_sub(amount_out)) * 10000) / expected_out;
122    impact.min(10000) as u16
123}
124
125/// Read bytes from instruction data
126pub fn read_bytes(data: &[u8], offset: usize, length: usize) -> Option<&[u8]> {
127    if data.len() < offset + length {
128        return None;
129    }
130    Some(&data[offset..offset + length])
131}
132
133/// `create_v2` 指令 payload（**不含** 8 字节 discriminator）：`name, symbol, uri, creator, is_mayhem_mode, is_cashback_enabled`（IDL）。
134/// 其中 `is_cashback_enabled` 为 `OptionBool`，链上与 `bool` 同为 1 字节。
135/// `mint` / `bonding_curve` / `user` 在账户里，不在 data 中。
136#[inline]
137pub fn parse_create_v2_tail_fields(data_after_discriminator: &[u8]) -> Option<(Pubkey, bool, bool)> {
138    let mut offset = 0usize;
139    let (_, l) = read_str_unchecked(data_after_discriminator, offset)?;
140    offset += l;
141    let (_, l) = read_str_unchecked(data_after_discriminator, offset)?;
142    offset += l;
143    let (_, l) = read_str_unchecked(data_after_discriminator, offset)?;
144    offset += l;
145    if data_after_discriminator.len() < offset + 32 + 1 {
146        return None;
147    }
148    let creator = read_pubkey(data_after_discriminator, offset)?;
149    offset += 32;
150    let is_mayhem_mode = read_bool(data_after_discriminator, offset)?;
151    offset += 1;
152    let is_cashback_enabled = if offset < data_after_discriminator.len() {
153        read_option_bool_idl(data_after_discriminator, offset).unwrap_or(false)
154    } else {
155        false
156    };
157    Some((creator, is_mayhem_mode, is_cashback_enabled))
158}
159
160/// Read string with 4-byte length prefix (Borsh format)
161/// Returns (string slice, total bytes consumed including length prefix)
162#[inline]
163pub fn read_str_unchecked(data: &[u8], offset: usize) -> Option<(&str, usize)> {
164    if data.len() < offset + 4 {
165        return None;
166    }
167    let len = u32::from_le_bytes(data[offset..offset + 4].try_into().ok()?) as usize;
168    if data.len() < offset + 4 + len {
169        return None;
170    }
171    let string_bytes = &data[offset + 4..offset + 4 + len];
172    let s = std::str::from_utf8(string_bytes).ok()?;
173    Some((s, 4 + len))
174}
175
176/// 从指令数据中读取u64向量（简化版本）
177pub fn read_vec_u64(_data: &[u8], _offset: usize) -> Option<Vec<u64>> {
178    // 简化版本：返回默认的两个元素向量
179    // 实际实现需要根据具体的数据格式来解析
180    Some(vec![0, 0])
181}
182
183/// 快速读取 Pubkey（从字节数组）
184#[inline(always)]
185pub fn read_pubkey_fast(bytes: &[u8]) -> Pubkey {
186    crate::logs::utils::read_pubkey(bytes, 0).unwrap_or_default()
187}
188
189/// 获取指令账户访问器
190/// 返回一个可以通过索引获取 Pubkey 的闭包
191pub fn get_instruction_account_getter<'a>(
192    meta: &'a TransactionStatusMeta,
193    transaction: &'a Option<Transaction>,
194    account_keys: Option<&'a Vec<Vec<u8>>>,
195    // 地址表
196    loaded_writable_addresses: &'a Vec<Vec<u8>>,
197    loaded_readonly_addresses: &'a Vec<Vec<u8>>,
198    index: &(i32, i32), // (outer_index, inner_index)
199) -> Option<impl Fn(usize) -> Pubkey + 'a> {
200    // 1. 获取指令的账户索引数组
201    let accounts = if index.1 >= 0 {
202        // 内层指令 - 使用二分查找优化 (inner_instructions 按 index 升序排列)
203        let outer_idx = index.0 as u32;
204        meta.inner_instructions
205            .binary_search_by_key(&outer_idx, |i| i.index)
206            .ok()
207            .and_then(|pos| meta.inner_instructions.get(pos))
208            .or_else(|| {
209                // 回退到线性查找（以防数据未排序）
210                meta.inner_instructions.iter().find(|i| i.index == outer_idx)
211            })?
212            .instructions
213            .get(index.1 as usize)?
214            .accounts
215            .as_slice()
216    } else {
217        // 外层指令
218        transaction
219            .as_ref()?
220            .message
221            .as_ref()?
222            .instructions
223            .get(index.0 as usize)?
224            .accounts
225            .as_slice()
226    };
227
228    // 2. 创建高性能的账户查找闭包
229    Some(move |acc_index: usize| -> Pubkey {
230        // 获取账户在交易中的索引
231        let account_index = match accounts.get(acc_index) {
232            Some(&idx) => idx as usize,
233            None => return Pubkey::default(),
234        };
235        // 早期返回优化
236        let Some(keys) = account_keys else {
237            return Pubkey::default();
238        };
239        // 主账户列表
240        if let Some(key_bytes) = keys.get(account_index) {
241            return read_pubkey_fast(key_bytes);
242        }
243        // 可写地址
244        let writable_offset = account_index.saturating_sub(keys.len());
245        if let Some(key_bytes) = loaded_writable_addresses.get(writable_offset) {
246            return read_pubkey_fast(key_bytes);
247        }
248        // 只读地址
249        let readonly_offset = writable_offset.saturating_sub(loaded_writable_addresses.len());
250        if let Some(key_bytes) = loaded_readonly_addresses.get(readonly_offset) {
251            return read_pubkey_fast(key_bytes);
252        }
253        Pubkey::default()
254    })
255}
256
257use crate::core::clock::now_us;
258/// 预构建的 inner_instructions 索引，用于 O(1) 查找
259use std::collections::HashMap;
260
261/// InnerInstructions 索引缓存
262pub struct InnerInstructionsIndex<'a> {
263    /// outer_index -> &InnerInstructions
264    index_map: HashMap<u32, &'a yellowstone_grpc_proto::prelude::InnerInstructions>,
265}
266
267impl<'a> InnerInstructionsIndex<'a> {
268    /// 从 TransactionStatusMeta 构建索引
269    #[inline]
270    pub fn new(meta: &'a TransactionStatusMeta) -> Self {
271        let mut index_map = HashMap::with_capacity(meta.inner_instructions.len());
272        for inner in &meta.inner_instructions {
273            index_map.insert(inner.index, inner);
274        }
275        Self { index_map }
276    }
277
278    /// O(1) 查找 inner_instructions
279    #[inline]
280    pub fn get(
281        &self,
282        outer_index: u32,
283    ) -> Option<&'a yellowstone_grpc_proto::prelude::InnerInstructions> {
284        self.index_map.get(&outer_index).copied()
285    }
286}
287
288/// 使用预构建索引的账户获取器（O(1) 查找）
289pub fn get_instruction_account_getter_indexed<'a>(
290    inner_index: &InnerInstructionsIndex<'a>,
291    transaction: &'a Option<Transaction>,
292    account_keys: Option<&'a Vec<Vec<u8>>>,
293    loaded_writable_addresses: &'a Vec<Vec<u8>>,
294    loaded_readonly_addresses: &'a Vec<Vec<u8>>,
295    index: &(i32, i32),
296) -> Option<impl Fn(usize) -> Pubkey + 'a> {
297    let accounts = if index.1 >= 0 {
298        // O(1) 查找
299        inner_index.get(index.0 as u32)?.instructions.get(index.1 as usize)?.accounts.as_slice()
300    } else {
301        transaction
302            .as_ref()?
303            .message
304            .as_ref()?
305            .instructions
306            .get(index.0 as usize)?
307            .accounts
308            .as_slice()
309    };
310
311    Some(move |acc_index: usize| -> Pubkey {
312        let account_index = match accounts.get(acc_index) {
313            Some(&idx) => idx as usize,
314            None => return Pubkey::default(),
315        };
316        let Some(keys) = account_keys else {
317            return Pubkey::default();
318        };
319        if let Some(key_bytes) = keys.get(account_index) {
320            return read_pubkey_fast(key_bytes);
321        }
322        let writable_offset = account_index.saturating_sub(keys.len());
323        if let Some(key_bytes) = loaded_writable_addresses.get(writable_offset) {
324            return read_pubkey_fast(key_bytes);
325        }
326        let readonly_offset = writable_offset.saturating_sub(loaded_writable_addresses.len());
327        if let Some(key_bytes) = loaded_readonly_addresses.get(readonly_offset) {
328            return read_pubkey_fast(key_bytes);
329        }
330        Pubkey::default()
331    })
332}
333
334#[cfg(test)]
335mod option_bool_tests {
336    use super::*;
337
338    #[test]
339    fn read_option_bool_idl_strict() {
340        assert_eq!(read_option_bool_idl(&[0], 0), Some(false));
341        assert_eq!(read_option_bool_idl(&[1], 0), Some(true));
342        assert_eq!(read_option_bool_idl(&[2], 0), None);
343    }
344
345    #[test]
346    fn parse_create_v2_tail_matches_anchor_len() {
347        // name "a", "b", "c" + creator (32) + mayhem (1) + OptionBool cashback (1) = 49 bytes payload
348        let mut p = Vec::new();
349        p.extend_from_slice(&(1u32.to_le_bytes()));
350        p.push(b'a');
351        p.extend_from_slice(&(1u32.to_le_bytes()));
352        p.push(b'b');
353        p.extend_from_slice(&(1u32.to_le_bytes()));
354        p.push(b'c');
355        p.extend_from_slice(&[0u8; 32]);
356        p.push(1u8); // mayhem
357        p.push(1u8); // cashback
358        assert_eq!(p.len(), 49);
359        let (creator, mayhem, cb) = parse_create_v2_tail_fields(&p).expect("parse");
360        assert_eq!(creator, Pubkey::default());
361        assert!(mayhem);
362        assert!(cb);
363    }
364}
sol_parser_sdk/instr/utils.rs

sol_parser_sdk/instr/
utils.rs
