Sasedev/khadhroony-bobobot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

0.7.36

Browse Source
This commit is contained in:
SinuS von SifriduS
2026-05-14 12:49:50 +02:00
parent 348ae7f153
commit edc8da02a3
12 changed files with 823 additions and 120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

165
kb_lib/src/dex/meteora_damm_v1.rs
View File

@@ -2,6 +2,14 @@
//! Meteora DAMM v1 transaction decoder.
const DAMM_V1_DISCRIMINATOR_INITIALIZE_POOL: [u8; 8] =
[0x5f, 0xb4, 0x0a, 0xac, 0x54, 0xae, 0xe8, 0x28];
const DAMM_V1_DISCRIMINATOR_INITIALIZE_POOL_WITH_CONFIG: [u8; 8] =
[0x49, 0xfe, 0x76, 0xf3, 0xab, 0xc4, 0x4c, 0xd0];
const DAMM_V1_DISCRIMINATOR_SWAP: [u8; 8] = [0xf8, 0xc6, 0x9e, 0x91, 0xe1, 0x75, 0x87, 0xc8];
/// Decoded Meteora DAMM v1 create-pool event.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct MeteoraDammV1CreatePoolDecoded {
@@ -109,9 +117,6 @@ impl MeteoraDammV1Decoder {
let log_messages = extract_log_messages(&transaction_json);
let mut decoded_events = std::vec::Vec::new();
for instruction in instructions {
if instruction.parent_instruction_id.is_some() {
continue;
}
let program_id_option = &instruction.program_id;
let program_id = match program_id_option {
Some(program_id) => program_id,
@@ -135,7 +140,20 @@ impl MeteoraDammV1Decoder {
Ok(parsed_json) => parsed_json,
Err(error) => return Err(error),
};
let instruction_kind = classify_instruction_kind(parsed_json.as_ref(), &log_messages);
let instruction_data_result =
decode_instruction_data_json(instruction.data_json.as_ref());
let instruction_data = match instruction_data_result {
Ok(instruction_data) => instruction_data,
Err(error) => return Err(error),
};
if instruction.parent_instruction_id.is_some() && instruction_data.is_none() {
continue;
}
let instruction_kind = classify_instruction_kind(
parsed_json.as_ref(),
instruction_data.as_deref(),
&log_messages,
);
let pool_account = extract_string_by_candidate_keys(
parsed_json.as_ref(),
&["pool", "poolAddress", "poolAccount", "amm", "ammPool", "poolState"],
@@ -169,6 +187,9 @@ impl MeteoraDammV1Decoder {
let payload_json = serde_json::json!({
"decoder": "meteora_damm_v1",
"eventKind": "create_pool",
"dataDiscriminatorHex": instruction_data
.as_ref()
.and_then(|data| return first_8_bytes_hex(data.as_slice())),
"classifiedInstructionKind": if used_config { "create_pool_with_config" } else { "create_pool" },
"signature": transaction.signature,
"instructionId": instruction_id,
@@ -204,6 +225,9 @@ impl MeteoraDammV1Decoder {
let payload_json = serde_json::json!({
"decoder": "meteora_damm_v1",
"eventKind": "swap",
"dataDiscriminatorHex": instruction_data
.as_ref()
.and_then(|data| return first_8_bytes_hex(data.as_slice())),
"classifiedInstructionKind": "swap",
"signature": transaction.signature,
"instructionId": instruction_id,
@@ -237,8 +261,16 @@ impl MeteoraDammV1Decoder {
fn classify_instruction_kind(
parsed_json: std::option::Option<&serde_json::Value>,
instruction_data: std::option::Option<&[u8]>,
log_messages: &[std::string::String],
) -> MeteoraDammV1InstructionKind {
let data_kind = classify_instruction_kind_from_data(instruction_data);
if data_kind != MeteoraDammV1InstructionKind::Unknown {
return data_kind;
}
if instruction_data_has_full_discriminator(instruction_data) {
return MeteoraDammV1InstructionKind::Unknown;
}
let parsed_instruction_name = extract_string_by_candidate_keys(
parsed_json,
&["instruction", "instructionName", "type", "name"],
@@ -274,6 +306,46 @@ fn classify_instruction_kind(
return MeteoraDammV1InstructionKind::Unknown;
}
fn instruction_data_has_full_discriminator(instruction_data: std::option::Option<&[u8]>) -> bool {
let instruction_data = match instruction_data {
Some(instruction_data) => instruction_data,
None => return false,
};
return instruction_data.len() >= 8;
}
fn classify_instruction_kind_from_data(
instruction_data: std::option::Option<&[u8]>,
) -> MeteoraDammV1InstructionKind {
let instruction_data = match instruction_data {
Some(instruction_data) => instruction_data,
None => return MeteoraDammV1InstructionKind::Unknown,
};
if instruction_data.len() < 8 {
return MeteoraDammV1InstructionKind::Unknown;
}
let discriminator = [
instruction_data[0],
instruction_data[1],
instruction_data[2],
instruction_data[3],
instruction_data[4],
instruction_data[5],
instruction_data[6],
instruction_data[7],
];
if discriminator == DAMM_V1_DISCRIMINATOR_INITIALIZE_POOL_WITH_CONFIG {
return MeteoraDammV1InstructionKind::CreatePoolWithConfig;
}
if discriminator == DAMM_V1_DISCRIMINATOR_INITIALIZE_POOL {
return MeteoraDammV1InstructionKind::CreatePool;
}
if discriminator == DAMM_V1_DISCRIMINATOR_SWAP {
return MeteoraDammV1InstructionKind::Swap;
}
return MeteoraDammV1InstructionKind::Unknown;
}
fn extract_log_messages(
transaction_json: &serde_json::Value,
) -> std::vec::Vec<std::string::String> {
@@ -341,6 +413,10 @@ fn parse_accounts_json(
let text_option = value.as_str();
if let Some(text) = text_option {
accounts.push(text.to_string());
continue;
}
if let Some(pubkey) = value.get("pubkey").and_then(|nested| return nested.as_str()) {
accounts.push(pubkey.to_string());
}
}
return Ok(accounts);
@@ -365,6 +441,48 @@ fn parse_optional_parsed_json(
}
}
fn decode_instruction_data_json(
data_json: std::option::Option<&std::string::String>,
) -> Result<std::option::Option<std::vec::Vec<u8>>, crate::Error> {
let data_json = match data_json {
Some(data_json) => data_json,
None => return Ok(None),
};
let value_result = serde_json::from_str::<serde_json::Value>(data_json.as_str());
let value = match value_result {
Ok(value) => value,
Err(error) => {
return Err(crate::Error::Json(format!(
"cannot parse Meteora DAMM v1 data_json: {}",
error
)));
},
};
if let serde_json::Value::String(base58_text) = value {
let decoded_result = bs58::decode(base58_text.as_str()).into_vec();
match decoded_result {
Ok(decoded) => return Ok(Some(decoded)),
Err(error) => {
return Err(crate::Error::Json(format!(
"cannot decode Meteora DAMM v1 instruction data from base58: {}",
error
)));
},
}
}
return Ok(None);
}
fn first_8_bytes_hex(bytes: &[u8]) -> std::option::Option<std::string::String> {
if bytes.len() < 8 {
return None;
}
return Some(format!(
"{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}{:02x}",
bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7],
));
}
fn extract_string_by_candidate_keys(
value: std::option::Option<&serde_json::Value>,
candidate_keys: &[&str],
@@ -640,4 +758,43 @@ mod tests {
},
}
}
#[test]
fn meteora_damm_v1_swap_discriminator_is_detected() {
let data = [0xf8, 0xc6, 0x9e, 0x91, 0xe1, 0x75, 0x87, 0xc8, 0x01];
let kind = super::classify_instruction_kind_from_data(Some(&data));
assert_eq!(kind, super::MeteoraDammV1InstructionKind::Swap);
}
#[test]
fn meteora_damm_v1_unknown_data_discriminator_does_not_fallback_to_global_swap_logs() {
let data = [0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x00, 0x11, 0x01];
let logs = vec!["Program log: Instruction: Swap".to_string()];
let kind = super::classify_instruction_kind(None, Some(&data), &logs);
assert_eq!(kind, super::MeteoraDammV1InstructionKind::Unknown);
}
#[test]
fn meteora_damm_v1_inner_swap_instruction_with_data_is_not_skipped() {
let decoder = crate::MeteoraDammV1Decoder::new();
let transaction = make_swap_transaction();
let mut instruction = make_swap_instruction();
instruction.parent_instruction_id = Some(500);
instruction.data_json = Some(format!(
"\"{}\"",
bs58::encode(&[0xf8_u8, 0xc6, 0x9e, 0x91, 0xe1, 0x75, 0x87, 0xc8, 0x01]).into_string()
));
let decoded_result = decoder.decode_transaction(&transaction, &[instruction]);
let decoded = match decoded_result {
Ok(decoded) => decoded,
Err(error) => panic!("decode must succeed: {}", error),
};
assert_eq!(decoded.len(), 1);
match &decoded[0] {
crate::MeteoraDammV1DecodedEvent::Swap(event) => {
assert_eq!(event.pool_account, Some("DammV1SwapPool111".to_string()));
},
crate::MeteoraDammV1DecodedEvent::CreatePool(_) => panic!("unexpected create event"),
}
}
}