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

242
kb_lib/src/dex/meteora_dbc.rs
View File

@@ -2,6 +2,16 @@
//! Meteora Dynamic Bonding Curve (DBC) transaction decoder.
const DBC_DISCRIMINATOR_CREATE_POOL: [u8; 8] = [0xe9, 0x92, 0xd1, 0x8e, 0xcf, 0x68, 0x40, 0xbc];
const DBC_DISCRIMINATOR_INITIALIZE_POOL: [u8; 8] = [0x5f, 0xb4, 0x0a, 0xac, 0x54, 0xae, 0xe8, 0x28];
const DBC_DISCRIMINATOR_LAUNCH_POOL: [u8; 8] = [0xa6, 0x77, 0xd1, 0xb6, 0xd6, 0x6d, 0x3a, 0xb5];
const DBC_DISCRIMINATOR_SWAP: [u8; 8] = [0xf8, 0xc6, 0x9e, 0x91, 0xe1, 0x75, 0x87, 0xc8];
const DBC_DISCRIMINATOR_SWAP2: [u8; 8] = [0x41, 0x4b, 0x3f, 0x4c, 0xeb, 0x5b, 0x5b, 0x88];
/// Decoded Meteora DBC create-pool event.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct MeteoraDbcCreatePoolDecoded {
@@ -106,9 +116,6 @@ impl MeteoraDbcDecoder {
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,
@@ -132,7 +139,20 @@ impl MeteoraDbcDecoder {
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", "poolAccount", "poolState", "virtualPool", "poolKey"],
@@ -162,6 +182,9 @@ impl MeteoraDbcDecoder {
let payload_json = serde_json::json!({
"decoder": "meteora_dbc",
"eventKind": "create_pool",
"dataDiscriminatorHex": instruction_data
.as_ref()
.and_then(|data| return first_8_bytes_hex(data.as_slice())),
"classifiedInstructionKind": "create_pool",
"signature": transaction.signature,
"instructionId": instruction_id,
@@ -193,10 +216,32 @@ impl MeteoraDbcDecoder {
}
if instruction_kind == MeteoraDbcInstructionKind::Swap {
let trade_side = infer_trade_side(&log_messages);
let has_trade_amount_payload =
parsed_json_has_trade_amount_or_price_payload(parsed_json.as_ref());
let event_actionability = if has_trade_amount_payload {
"trade_candidate"
} else {
"non_actionable_trade"
};
let materialization_skip_reason = if has_trade_amount_payload {
serde_json::Value::Null
} else {
serde_json::Value::String("swap_without_amount_payload".to_string())
};
let payload_json = serde_json::json!({
"decoder": "meteora_dbc",
"eventKind": "swap",
"dataDiscriminatorHex": instruction_data
.as_ref()
.and_then(|data| return first_8_bytes_hex(data.as_slice())),
"classifiedInstructionKind": "swap",
"eventCategory": "trade",
"eventLifecycleKind": "trade_swap",
"eventActionability": event_actionability,
"tradeCandidate": has_trade_amount_payload,
"candleCandidate": has_trade_amount_payload,
"nonTradeUseful": false,
"materializationSkipReason": materialization_skip_reason,
"signature": transaction.signature,
"instructionId": instruction_id,
"instructionIndex": instruction.instruction_index,
@@ -306,6 +351,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);
@@ -411,6 +460,48 @@ fn value_contains_any_key_inner(value: &serde_json::Value, candidate_keys: &[&st
return false;
}
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 parsed_result = serde_json::from_str::<serde_json::Value>(data_json.as_str());
let parsed = match parsed_result {
Ok(parsed) => parsed,
Err(error) => {
return Err(crate::Error::Json(format!(
"cannot parse Meteora DBC data_json: {}",
error
)));
},
};
if let serde_json::Value::String(base58_text) = parsed {
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 DBC 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_account(
accounts: &[std::string::String],
index: usize,
@@ -433,8 +524,16 @@ fn infer_trade_side(log_messages: &[std::string::String]) -> crate::SwapTradeSid
fn classify_instruction_kind(
parsed_json: std::option::Option<&serde_json::Value>,
instruction_data: std::option::Option<&[u8]>,
log_messages: &[std::string::String],
) -> MeteoraDbcInstructionKind {
let data_kind = classify_instruction_kind_from_data(instruction_data);
if data_kind != MeteoraDbcInstructionKind::Unknown {
return data_kind;
}
if instruction_data_has_full_discriminator(instruction_data) {
return MeteoraDbcInstructionKind::Unknown;
}
let parsed_instruction_name = extract_string_by_candidate_keys(
parsed_json,
&["instruction", "instructionName", "type", "name"],
@@ -470,6 +569,102 @@ fn classify_instruction_kind(
return MeteoraDbcInstructionKind::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]>,
) -> MeteoraDbcInstructionKind {
let instruction_data = match instruction_data {
Some(instruction_data) => instruction_data,
None => return MeteoraDbcInstructionKind::Unknown,
};
if instruction_data.len() < 8 {
return MeteoraDbcInstructionKind::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 == DBC_DISCRIMINATOR_CREATE_POOL
|| discriminator == DBC_DISCRIMINATOR_INITIALIZE_POOL
|| discriminator == DBC_DISCRIMINATOR_LAUNCH_POOL
{
return MeteoraDbcInstructionKind::CreatePool;
}
if discriminator == DBC_DISCRIMINATOR_SWAP || discriminator == DBC_DISCRIMINATOR_SWAP2 {
return MeteoraDbcInstructionKind::Swap;
}
return MeteoraDbcInstructionKind::Unknown;
}
fn parsed_json_has_trade_amount_or_price_payload(
parsed_json: std::option::Option<&serde_json::Value>,
) -> bool {
let parsed_json = match parsed_json {
Some(parsed_json) => parsed_json,
None => return false,
};
return json_value_contains_any_trade_amount_or_price_key(parsed_json);
}
fn json_value_contains_any_trade_amount_or_price_key(value: &serde_json::Value) -> bool {
match value {
serde_json::Value::Object(map) => {
for key in map.keys() {
let normalized = normalize_log_text(key.as_str());
if is_trade_amount_or_price_key(normalized.as_str()) {
return true;
}
}
for child in map.values() {
if json_value_contains_any_trade_amount_or_price_key(child) {
return true;
}
}
return false;
},
serde_json::Value::Array(values) => {
for child in values {
if json_value_contains_any_trade_amount_or_price_key(child) {
return true;
}
}
return false;
},
_ => return false,
}
}
fn is_trade_amount_or_price_key(normalized_key: &str) -> bool {
return normalized_key == "baseamountraw"
|| normalized_key == "quoteamountraw"
|| normalized_key == "baseamount"
|| normalized_key == "quoteamount"
|| normalized_key == "amountin"
|| normalized_key == "amountout"
|| normalized_key == "tokenain"
|| normalized_key == "tokenaout"
|| normalized_key == "tokenbin"
|| normalized_key == "tokenbout"
|| normalized_key == "inputamount"
|| normalized_key == "outputamount"
|| normalized_key == "swapamount"
|| normalized_key == "price"
|| normalized_key == "pricequoteperbase";
}
#[cfg(test)]
mod tests {
fn make_create_transaction() -> crate::ChainTransactionDto {
@@ -688,4 +883,43 @@ mod tests {
},
}
}
#[test]
fn meteora_dbc_swap2_discriminator_is_detected() {
let data = [0x41, 0x4b, 0x3f, 0x4c, 0xeb, 0x5b, 0x5b, 0x88, 0x01];
let kind = super::classify_instruction_kind_from_data(Some(&data));
assert_eq!(kind, super::MeteoraDbcInstructionKind::Swap);
}
#[test]
fn meteora_dbc_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: Swap2".to_string()];
let kind = super::classify_instruction_kind(None, Some(&data), &logs);
assert_eq!(kind, super::MeteoraDbcInstructionKind::Unknown);
}
#[test]
fn meteora_dbc_inner_swap2_instruction_with_data_is_not_skipped() {
let decoder = crate::MeteoraDbcDecoder::new();
let transaction = make_swap_transaction();
let mut instruction = make_swap_instruction();
instruction.parent_instruction_id = Some(300);
instruction.data_json = Some(format!(
"\"{}\"",
bs58::encode(&[0x41_u8, 0x4b, 0x3f, 0x4c, 0xeb, 0x5b, 0x5b, 0x88, 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::MeteoraDbcDecodedEvent::Swap(event) => {
assert_eq!(event.pool_account, Some("DbcPoolSwap111".to_string()));
},
crate::MeteoraDbcDecodedEvent::CreatePool(_) => panic!("unexpected create event"),
}
}
}