716 lines
25 KiB
Rust
716 lines
25 KiB
Rust
// file: kb_lib/src/dex/meteora_dbc.rs
|
|
|
|
//! Meteora Dynamic Bonding Curve (DBC) transaction decoder.
|
|
|
|
/// Meteora DBC program id.
|
|
pub const KB_METEORA_DBC_PROGRAM_ID: &str = "dbcij3LWUppWqq96dh6gJWwBifmcGfLSB5D4DuSMaqN";
|
|
|
|
/// Decoded Meteora DBC create-pool event.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct KbMeteoraDbcCreatePoolDecoded {
|
|
/// Parent transaction id.
|
|
pub transaction_id: i64,
|
|
/// Parent instruction id.
|
|
pub instruction_id: i64,
|
|
/// Transaction signature.
|
|
pub signature: std::string::String,
|
|
/// Program id.
|
|
pub program_id: std::string::String,
|
|
/// Optional pool account.
|
|
pub pool_account: std::option::Option<std::string::String>,
|
|
/// Optional base mint.
|
|
pub token_a_mint: std::option::Option<std::string::String>,
|
|
/// Optional quote mint.
|
|
pub token_b_mint: std::option::Option<std::string::String>,
|
|
/// Optional config account.
|
|
pub config_account: std::option::Option<std::string::String>,
|
|
/// Optional creator.
|
|
pub creator: std::option::Option<std::string::String>,
|
|
/// Decoded payload.
|
|
pub payload_json: serde_json::Value,
|
|
}
|
|
|
|
/// Decoded Meteora DBC swap event.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub struct KbMeteoraDbcSwapDecoded {
|
|
/// Parent transaction id.
|
|
pub transaction_id: i64,
|
|
/// Parent instruction id.
|
|
pub instruction_id: i64,
|
|
/// Transaction signature.
|
|
pub signature: std::string::String,
|
|
/// Program id.
|
|
pub program_id: std::string::String,
|
|
/// Trade side relative to normalized base.
|
|
pub trade_side: crate::KbSwapTradeSide,
|
|
/// Optional pool account.
|
|
pub pool_account: std::option::Option<std::string::String>,
|
|
/// Optional base mint.
|
|
pub token_a_mint: std::option::Option<std::string::String>,
|
|
/// Optional quote mint.
|
|
pub token_b_mint: std::option::Option<std::string::String>,
|
|
/// Decoded payload.
|
|
pub payload_json: serde_json::Value,
|
|
}
|
|
|
|
/// Decoded Meteora DBC event.
|
|
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
|
pub enum KbMeteoraDbcDecodedEvent {
|
|
/// Create pool / launch pool.
|
|
CreatePool(KbMeteoraDbcCreatePoolDecoded),
|
|
/// Swap / swap2.
|
|
Swap(KbMeteoraDbcSwapDecoded),
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
enum KbMeteoraDbcInstructionKind {
|
|
CreatePool,
|
|
Swap,
|
|
Unknown,
|
|
}
|
|
|
|
/// Meteora DBC decoder.
|
|
#[derive(Debug, Clone, Default)]
|
|
pub struct KbMeteoraDbcDecoder;
|
|
|
|
impl KbMeteoraDbcDecoder {
|
|
/// Creates a new decoder.
|
|
pub fn new() -> Self {
|
|
Self
|
|
}
|
|
|
|
/// Decodes one projected transaction into zero or more Meteora DBC events.
|
|
pub fn decode_transaction(
|
|
&self,
|
|
transaction: &crate::KbChainTransactionDto,
|
|
instructions: &[crate::KbChainInstructionDto],
|
|
) -> Result<std::vec::Vec<crate::KbMeteoraDbcDecodedEvent>, crate::KbError> {
|
|
let transaction_id_option = transaction.id;
|
|
let transaction_id = match transaction_id_option {
|
|
Some(transaction_id) => transaction_id,
|
|
None => {
|
|
return Err(crate::KbError::InvalidState(format!(
|
|
"chain transaction '{}' has no internal id",
|
|
transaction.signature
|
|
)));
|
|
}
|
|
};
|
|
let transaction_json_result =
|
|
serde_json::from_str::<serde_json::Value>(transaction.transaction_json.as_str());
|
|
let transaction_json = match transaction_json_result {
|
|
Ok(transaction_json) => transaction_json,
|
|
Err(error) => {
|
|
return Err(crate::KbError::Json(format!(
|
|
"cannot parse transaction_json for signature '{}': {}",
|
|
transaction.signature, error
|
|
)));
|
|
}
|
|
};
|
|
let log_messages = kb_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,
|
|
None => continue,
|
|
};
|
|
if program_id.as_str() != crate::KB_METEORA_DBC_PROGRAM_ID {
|
|
continue;
|
|
}
|
|
let instruction_id_option = instruction.id;
|
|
let instruction_id = match instruction_id_option {
|
|
Some(instruction_id) => instruction_id,
|
|
None => continue,
|
|
};
|
|
let accounts_result = kb_parse_accounts_json(instruction.accounts_json.as_str());
|
|
let accounts = match accounts_result {
|
|
Ok(accounts) => accounts,
|
|
Err(error) => return Err(error),
|
|
};
|
|
let parsed_json_result =
|
|
kb_parse_optional_parsed_json(instruction.parsed_json.as_ref());
|
|
let parsed_json = match parsed_json_result {
|
|
Ok(parsed_json) => parsed_json,
|
|
Err(error) => return Err(error),
|
|
};
|
|
let instruction_kind =
|
|
kb_classify_instruction_kind(parsed_json.as_ref(), &log_messages);
|
|
let pool_account = kb_extract_string_by_candidate_keys(
|
|
parsed_json.as_ref(),
|
|
&["pool", "poolAccount", "poolState", "virtualPool", "poolKey"],
|
|
)
|
|
.or_else(|| kb_extract_account(&accounts, 0));
|
|
let token_a_mint = kb_extract_string_by_candidate_keys(
|
|
parsed_json.as_ref(),
|
|
&["baseMint", "tokenAMint", "mintA", "token0Mint", "mint0"],
|
|
)
|
|
.or_else(|| kb_extract_account(&accounts, 1));
|
|
let token_b_mint = kb_extract_string_by_candidate_keys(
|
|
parsed_json.as_ref(),
|
|
&["quoteMint", "tokenBMint", "mintB", "token1Mint", "mint1"],
|
|
)
|
|
.or_else(|| kb_extract_account(&accounts, 2));
|
|
let config_account = kb_extract_string_by_candidate_keys(
|
|
parsed_json.as_ref(),
|
|
&["poolConfig", "config", "dbcConfig", "curveConfig"],
|
|
)
|
|
.or_else(|| kb_extract_account(&accounts, 3));
|
|
let creator = kb_extract_string_by_candidate_keys(
|
|
parsed_json.as_ref(),
|
|
&["creator", "poolCreator", "owner", "user"],
|
|
)
|
|
.or_else(|| kb_extract_account(&accounts, 4));
|
|
if instruction_kind == KbMeteoraDbcInstructionKind::CreatePool {
|
|
let payload_json = serde_json::json!({
|
|
"decoder": "meteora_dbc",
|
|
"eventKind": "create_pool",
|
|
"classifiedInstructionKind": "create_pool",
|
|
"signature": transaction.signature,
|
|
"instructionId": instruction_id,
|
|
"instructionIndex": instruction.instruction_index,
|
|
"accounts": accounts,
|
|
"parsed": parsed_json,
|
|
"logMessages": log_messages,
|
|
"poolAccount": pool_account,
|
|
"tokenAMint": token_a_mint,
|
|
"tokenBMint": token_b_mint,
|
|
"configAccount": config_account,
|
|
"creator": creator
|
|
});
|
|
decoded_events.push(crate::KbMeteoraDbcDecodedEvent::CreatePool(
|
|
crate::KbMeteoraDbcCreatePoolDecoded {
|
|
transaction_id,
|
|
instruction_id,
|
|
signature: transaction.signature.clone(),
|
|
program_id: program_id.clone(),
|
|
pool_account,
|
|
token_a_mint,
|
|
token_b_mint,
|
|
config_account,
|
|
creator,
|
|
payload_json,
|
|
},
|
|
));
|
|
continue;
|
|
}
|
|
if instruction_kind == KbMeteoraDbcInstructionKind::Swap {
|
|
let trade_side = kb_infer_trade_side(&log_messages);
|
|
let payload_json = serde_json::json!({
|
|
"decoder": "meteora_dbc",
|
|
"eventKind": "swap",
|
|
"classifiedInstructionKind": "swap",
|
|
"signature": transaction.signature,
|
|
"instructionId": instruction_id,
|
|
"instructionIndex": instruction.instruction_index,
|
|
"accounts": accounts,
|
|
"parsed": parsed_json,
|
|
"logMessages": log_messages,
|
|
"poolAccount": pool_account,
|
|
"tokenAMint": token_a_mint,
|
|
"tokenBMint": token_b_mint,
|
|
"tradeSide": format!("{:?}", trade_side)
|
|
});
|
|
decoded_events.push(crate::KbMeteoraDbcDecodedEvent::Swap(
|
|
crate::KbMeteoraDbcSwapDecoded {
|
|
transaction_id,
|
|
instruction_id,
|
|
signature: transaction.signature.clone(),
|
|
program_id: program_id.clone(),
|
|
trade_side,
|
|
pool_account,
|
|
token_a_mint,
|
|
token_b_mint,
|
|
payload_json,
|
|
},
|
|
));
|
|
}
|
|
}
|
|
Ok(decoded_events)
|
|
}
|
|
}
|
|
|
|
fn kb_extract_log_messages(
|
|
transaction_json: &serde_json::Value,
|
|
) -> std::vec::Vec<std::string::String> {
|
|
let mut messages = std::vec::Vec::new();
|
|
let meta_option = transaction_json.get("meta");
|
|
let meta = match meta_option {
|
|
Some(meta) => meta,
|
|
None => return messages,
|
|
};
|
|
let logs_option = meta.get("logMessages");
|
|
let logs = match logs_option {
|
|
Some(logs) => logs,
|
|
None => return messages,
|
|
};
|
|
let logs_array_option = logs.as_array();
|
|
let logs_array = match logs_array_option {
|
|
Some(logs_array) => logs_array,
|
|
None => return messages,
|
|
};
|
|
for value in logs_array {
|
|
let text_option = value.as_str();
|
|
if let Some(text) = text_option {
|
|
messages.push(text.to_string());
|
|
}
|
|
}
|
|
messages
|
|
}
|
|
|
|
fn kb_log_messages_contain_any_keyword(
|
|
log_messages: &[std::string::String],
|
|
keywords: &[&str],
|
|
) -> bool {
|
|
for keyword in keywords {
|
|
if kb_log_messages_contain_keyword(log_messages, keyword) {
|
|
return true;
|
|
}
|
|
}
|
|
false
|
|
}
|
|
|
|
fn kb_log_messages_contain_keyword(log_messages: &[std::string::String], keyword: &str) -> bool {
|
|
let keyword_normalized = kb_normalize_log_text(keyword);
|
|
for log_message in log_messages {
|
|
let log_normalized = kb_normalize_log_text(log_message.as_str());
|
|
if log_normalized.contains(keyword_normalized.as_str()) {
|
|
return true;
|
|
}
|
|
}
|
|
false
|
|
}
|
|
|
|
fn kb_normalize_log_text(value: &str) -> std::string::String {
|
|
let mut normalized = std::string::String::new();
|
|
for character in value.chars() {
|
|
if character.is_ascii_alphanumeric() {
|
|
normalized.push(character.to_ascii_lowercase());
|
|
}
|
|
}
|
|
normalized
|
|
}
|
|
|
|
fn kb_parse_accounts_json(
|
|
accounts_json: &str,
|
|
) -> Result<std::vec::Vec<std::string::String>, crate::KbError> {
|
|
let values_result = serde_json::from_str::<std::vec::Vec<serde_json::Value>>(accounts_json);
|
|
let values = match values_result {
|
|
Ok(values) => values,
|
|
Err(error) => {
|
|
return Err(crate::KbError::Json(format!(
|
|
"cannot parse instruction accounts_json '{}': {}",
|
|
accounts_json, error
|
|
)));
|
|
}
|
|
};
|
|
let mut accounts = std::vec::Vec::new();
|
|
for value in values {
|
|
let text_option = value.as_str();
|
|
if let Some(text) = text_option {
|
|
accounts.push(text.to_string());
|
|
}
|
|
}
|
|
Ok(accounts)
|
|
}
|
|
|
|
fn kb_parse_optional_parsed_json(
|
|
parsed_json: std::option::Option<&std::string::String>,
|
|
) -> Result<std::option::Option<serde_json::Value>, crate::KbError> {
|
|
let parsed_json = match parsed_json {
|
|
Some(parsed_json) => parsed_json,
|
|
None => return Ok(None),
|
|
};
|
|
let value_result = serde_json::from_str::<serde_json::Value>(parsed_json.as_str());
|
|
match value_result {
|
|
Ok(value) => Ok(Some(value)),
|
|
Err(error) => Err(crate::KbError::Json(format!(
|
|
"cannot parse instruction parsed_json '{}': {}",
|
|
parsed_json, error
|
|
))),
|
|
}
|
|
}
|
|
|
|
fn kb_extract_string_by_candidate_keys(
|
|
value: std::option::Option<&serde_json::Value>,
|
|
candidate_keys: &[&str],
|
|
) -> std::option::Option<std::string::String> {
|
|
let value = match value {
|
|
Some(value) => value,
|
|
None => return None,
|
|
};
|
|
kb_extract_string_by_candidate_keys_inner(value, candidate_keys)
|
|
}
|
|
|
|
fn kb_extract_string_by_candidate_keys_inner(
|
|
value: &serde_json::Value,
|
|
candidate_keys: &[&str],
|
|
) -> std::option::Option<std::string::String> {
|
|
if let Some(object) = value.as_object() {
|
|
for candidate_key in candidate_keys {
|
|
let direct_option = object.get(*candidate_key);
|
|
if let Some(direct) = direct_option {
|
|
let direct_text_option = direct.as_str();
|
|
if let Some(direct_text) = direct_text_option {
|
|
return Some(direct_text.to_string());
|
|
}
|
|
}
|
|
}
|
|
for nested_value in object.values() {
|
|
let nested_result =
|
|
kb_extract_string_by_candidate_keys_inner(nested_value, candidate_keys);
|
|
if nested_result.is_some() {
|
|
return nested_result;
|
|
}
|
|
}
|
|
return None;
|
|
}
|
|
if let Some(array) = value.as_array() {
|
|
for nested_value in array {
|
|
let nested_result =
|
|
kb_extract_string_by_candidate_keys_inner(nested_value, candidate_keys);
|
|
if nested_result.is_some() {
|
|
return nested_result;
|
|
}
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
fn kb_value_contains_any_key(
|
|
value: std::option::Option<&serde_json::Value>,
|
|
candidate_keys: &[&str],
|
|
) -> bool {
|
|
let value = match value {
|
|
Some(value) => value,
|
|
None => return false,
|
|
};
|
|
kb_value_contains_any_key_inner(value, candidate_keys)
|
|
}
|
|
|
|
fn kb_value_contains_any_key_inner(value: &serde_json::Value, candidate_keys: &[&str]) -> bool {
|
|
if let Some(object) = value.as_object() {
|
|
for candidate_key in candidate_keys {
|
|
if object.contains_key(*candidate_key) {
|
|
return true;
|
|
}
|
|
}
|
|
for nested_value in object.values() {
|
|
if kb_value_contains_any_key_inner(nested_value, candidate_keys) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
if let Some(array) = value.as_array() {
|
|
for nested_value in array {
|
|
if kb_value_contains_any_key_inner(nested_value, candidate_keys) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
false
|
|
}
|
|
|
|
fn kb_extract_account(
|
|
accounts: &[std::string::String],
|
|
index: usize,
|
|
) -> std::option::Option<std::string::String> {
|
|
if index >= accounts.len() {
|
|
return None;
|
|
}
|
|
Some(accounts[index].clone())
|
|
}
|
|
|
|
fn kb_infer_trade_side(log_messages: &[std::string::String]) -> crate::KbSwapTradeSide {
|
|
if kb_log_messages_contain_keyword(log_messages, "buy") {
|
|
return crate::KbSwapTradeSide::BuyBase;
|
|
}
|
|
if kb_log_messages_contain_keyword(log_messages, "sell") {
|
|
return crate::KbSwapTradeSide::SellBase;
|
|
}
|
|
crate::KbSwapTradeSide::Unknown
|
|
}
|
|
|
|
fn kb_classify_instruction_kind(
|
|
parsed_json: std::option::Option<&serde_json::Value>,
|
|
log_messages: &[std::string::String],
|
|
) -> KbMeteoraDbcInstructionKind {
|
|
let parsed_instruction_name = kb_extract_string_by_candidate_keys(
|
|
parsed_json,
|
|
&["instruction", "instructionName", "type", "name"],
|
|
);
|
|
if let Some(parsed_instruction_name) = parsed_instruction_name {
|
|
let normalized = kb_normalize_log_text(parsed_instruction_name.as_str());
|
|
if normalized.contains("createpool")
|
|
|| normalized.contains("initializepool")
|
|
|| normalized.contains("launchpool")
|
|
{
|
|
return KbMeteoraDbcInstructionKind::CreatePool;
|
|
}
|
|
if normalized == "swap" || normalized == "swap2" {
|
|
return KbMeteoraDbcInstructionKind::Swap;
|
|
}
|
|
}
|
|
let has_create_config = kb_value_contains_any_key(
|
|
parsed_json,
|
|
&[
|
|
"poolConfig",
|
|
"migrationQuoteThreshold",
|
|
"curveConfig",
|
|
"dbcConfig",
|
|
],
|
|
);
|
|
if has_create_config {
|
|
return KbMeteoraDbcInstructionKind::CreatePool;
|
|
}
|
|
if kb_log_messages_contain_any_keyword(
|
|
log_messages,
|
|
&[
|
|
"create_pool",
|
|
"createpool",
|
|
"initialize_pool",
|
|
"initializepool",
|
|
"launch_pool",
|
|
],
|
|
) {
|
|
return KbMeteoraDbcInstructionKind::CreatePool;
|
|
}
|
|
if kb_log_messages_contain_any_keyword(log_messages, &["swap2", "swap"]) {
|
|
return KbMeteoraDbcInstructionKind::Swap;
|
|
}
|
|
KbMeteoraDbcInstructionKind::Unknown
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
fn make_create_transaction() -> crate::KbChainTransactionDto {
|
|
let mut dto = crate::KbChainTransactionDto::new(
|
|
"sig-meteora-dbc-create-1".to_string(),
|
|
Some(888001),
|
|
Some(1779300001),
|
|
Some("helius_primary_http".to_string()),
|
|
Some("0".to_string()),
|
|
None,
|
|
None,
|
|
serde_json::json!({
|
|
"slot": 888001,
|
|
"meta": {
|
|
"logMessages": [
|
|
"Program log: Instruction: CreatePool"
|
|
]
|
|
},
|
|
"transaction": {
|
|
"message": {
|
|
"instructions": []
|
|
}
|
|
}
|
|
})
|
|
.to_string(),
|
|
);
|
|
dto.id = Some(301);
|
|
dto
|
|
}
|
|
|
|
fn make_create_instruction() -> crate::KbChainInstructionDto {
|
|
let mut dto = crate::KbChainInstructionDto::new(
|
|
301,
|
|
None,
|
|
0,
|
|
None,
|
|
Some(crate::KB_METEORA_DBC_PROGRAM_ID.to_string()),
|
|
Some("meteora-dbc".to_string()),
|
|
Some(1),
|
|
serde_json::json!([
|
|
"DbcPool111",
|
|
"DbcTokenA111",
|
|
"So11111111111111111111111111111111111111112",
|
|
"DbcConfig111",
|
|
"DbcCreator111"
|
|
])
|
|
.to_string(),
|
|
None,
|
|
None,
|
|
Some(
|
|
serde_json::json!({
|
|
"info": {
|
|
"pool": "DbcPool111",
|
|
"baseMint": "DbcTokenA111",
|
|
"quoteMint": "So11111111111111111111111111111111111111112",
|
|
"poolConfig": "DbcConfig111",
|
|
"creator": "DbcCreator111"
|
|
}
|
|
})
|
|
.to_string(),
|
|
),
|
|
);
|
|
dto.id = Some(302);
|
|
dto
|
|
}
|
|
|
|
fn make_swap_transaction() -> crate::KbChainTransactionDto {
|
|
let mut dto = crate::KbChainTransactionDto::new(
|
|
"sig-meteora-dbc-swap-1".to_string(),
|
|
Some(888002),
|
|
Some(1779300002),
|
|
Some("helius_primary_http".to_string()),
|
|
Some("0".to_string()),
|
|
None,
|
|
None,
|
|
serde_json::json!({
|
|
"slot": 888002,
|
|
"meta": {
|
|
"logMessages": [
|
|
"Program log: Instruction: Swap2"
|
|
]
|
|
},
|
|
"transaction": {
|
|
"message": {
|
|
"instructions": []
|
|
}
|
|
}
|
|
})
|
|
.to_string(),
|
|
);
|
|
dto.id = Some(303);
|
|
dto
|
|
}
|
|
|
|
fn make_swap_instruction() -> crate::KbChainInstructionDto {
|
|
let mut dto = crate::KbChainInstructionDto::new(
|
|
303,
|
|
None,
|
|
0,
|
|
None,
|
|
Some(crate::KB_METEORA_DBC_PROGRAM_ID.to_string()),
|
|
Some("meteora-dbc".to_string()),
|
|
Some(1),
|
|
serde_json::json!([
|
|
"DbcPoolSwap111",
|
|
"DbcSwapTokenA111",
|
|
"So11111111111111111111111111111111111111112"
|
|
])
|
|
.to_string(),
|
|
None,
|
|
None,
|
|
Some(
|
|
serde_json::json!({
|
|
"info": {
|
|
"pool": "DbcPoolSwap111",
|
|
"baseMint": "DbcSwapTokenA111",
|
|
"quoteMint": "So11111111111111111111111111111111111111112"
|
|
}
|
|
})
|
|
.to_string(),
|
|
),
|
|
);
|
|
dto.id = Some(304);
|
|
dto
|
|
}
|
|
|
|
#[test]
|
|
fn meteora_dbc_create_pool_is_detected() {
|
|
let decoder = crate::KbMeteoraDbcDecoder::new();
|
|
let transaction = make_create_transaction();
|
|
let instructions = vec![make_create_instruction()];
|
|
let decoded_result = decoder.decode_transaction(&transaction, &instructions);
|
|
let decoded = match decoded_result {
|
|
Ok(decoded) => decoded,
|
|
Err(error) => panic!("decode must succeed: {}", error),
|
|
};
|
|
assert_eq!(decoded.len(), 1);
|
|
match &decoded[0] {
|
|
crate::KbMeteoraDbcDecodedEvent::CreatePool(event) => {
|
|
assert_eq!(event.transaction_id, 301);
|
|
assert_eq!(event.instruction_id, 302);
|
|
assert_eq!(event.pool_account, Some("DbcPool111".to_string()));
|
|
assert_eq!(event.token_a_mint, Some("DbcTokenA111".to_string()));
|
|
assert_eq!(
|
|
event.token_b_mint,
|
|
Some("So11111111111111111111111111111111111111112".to_string())
|
|
);
|
|
assert_eq!(event.config_account, Some("DbcConfig111".to_string()));
|
|
}
|
|
crate::KbMeteoraDbcDecodedEvent::Swap(_) => {
|
|
panic!("unexpected swap event")
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn meteora_dbc_swap_is_detected() {
|
|
let decoder = crate::KbMeteoraDbcDecoder::new();
|
|
let transaction = make_swap_transaction();
|
|
let instructions = vec![make_swap_instruction()];
|
|
let decoded_result = decoder.decode_transaction(&transaction, &instructions);
|
|
let decoded = match decoded_result {
|
|
Ok(decoded) => decoded,
|
|
Err(error) => panic!("decode must succeed: {}", error),
|
|
};
|
|
assert_eq!(decoded.len(), 1);
|
|
match &decoded[0] {
|
|
crate::KbMeteoraDbcDecodedEvent::Swap(event) => {
|
|
assert_eq!(event.transaction_id, 303);
|
|
assert_eq!(event.instruction_id, 304);
|
|
assert_eq!(event.pool_account, Some("DbcPoolSwap111".to_string()));
|
|
assert_eq!(event.token_a_mint, Some("DbcSwapTokenA111".to_string()));
|
|
assert_eq!(
|
|
event.token_b_mint,
|
|
Some("So11111111111111111111111111111111111111112".to_string())
|
|
);
|
|
}
|
|
crate::KbMeteoraDbcDecodedEvent::CreatePool(_) => {
|
|
panic!("unexpected create event")
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn meteora_dbc_quote_mint_alone_does_not_trigger_create_pool() {
|
|
let decoder = crate::KbMeteoraDbcDecoder::new();
|
|
let transaction = make_swap_transaction();
|
|
let mut instruction = make_swap_instruction();
|
|
instruction.parsed_json = Some(
|
|
serde_json::json!({
|
|
"info": {
|
|
"quoteMint": "So11111111111111111111111111111111111111112"
|
|
}
|
|
})
|
|
.to_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::KbMeteoraDbcDecodedEvent::Swap(_) => {}
|
|
crate::KbMeteoraDbcDecodedEvent::CreatePool(_) => {
|
|
panic!("unexpected create event")
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn meteora_dbc_pool_config_triggers_create_pool() {
|
|
let decoder = crate::KbMeteoraDbcDecoder::new();
|
|
let transaction = make_create_transaction();
|
|
let instruction = make_create_instruction();
|
|
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::KbMeteoraDbcDecodedEvent::CreatePool(_) => {}
|
|
crate::KbMeteoraDbcDecodedEvent::Swap(_) => {
|
|
panic!("unexpected swap event")
|
|
}
|
|
}
|
|
}
|
|
}
|