0.7.15
This commit is contained in:
488
kb_lib/src/wallet_observation.rs
Normal file
488
kb_lib/src/wallet_observation.rs
Normal file
@@ -0,0 +1,488 @@
|
||||
// file: kb_lib/src/wallet_observation.rs
|
||||
|
||||
//! Wallet-observation service.
|
||||
|
||||
/// One wallet-observation result.
|
||||
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
|
||||
pub struct KbWalletObservationResult {
|
||||
/// Related wallet id.
|
||||
pub wallet_id: i64,
|
||||
/// Wallet address.
|
||||
pub wallet_address: std::string::String,
|
||||
/// Persisted wallet-participation id.
|
||||
pub wallet_participation_id: i64,
|
||||
/// Stable observed role.
|
||||
pub role: std::string::String,
|
||||
/// Optional related pool id.
|
||||
pub pool_id: std::option::Option<i64>,
|
||||
/// Optional related pair id.
|
||||
pub pair_id: std::option::Option<i64>,
|
||||
/// Whether the participation row was newly created.
|
||||
pub created_participation: bool,
|
||||
}
|
||||
|
||||
/// Wallet-observation service.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct KbWalletObservationService {
|
||||
database: std::sync::Arc<crate::KbDatabase>,
|
||||
persistence: crate::KbDetectionPersistenceService,
|
||||
}
|
||||
|
||||
impl KbWalletObservationService {
|
||||
/// Creates a new wallet-observation service.
|
||||
pub fn new(database: std::sync::Arc<crate::KbDatabase>) -> Self {
|
||||
let persistence = crate::KbDetectionPersistenceService::new(database.clone());
|
||||
Self {
|
||||
database,
|
||||
persistence,
|
||||
}
|
||||
}
|
||||
|
||||
/// Records observed wallets and participations for one resolved transaction signature.
|
||||
pub async fn record_transaction_by_signature(
|
||||
&self,
|
||||
signature: &str,
|
||||
) -> Result<std::vec::Vec<crate::KbWalletObservationResult>, crate::KbError> {
|
||||
let transaction_result =
|
||||
crate::get_chain_transaction_by_signature(self.database.as_ref(), signature).await;
|
||||
let transaction_option = match transaction_result {
|
||||
Ok(transaction_option) => transaction_option,
|
||||
Err(error) => return Err(error),
|
||||
};
|
||||
let transaction = match transaction_option {
|
||||
Some(transaction) => transaction,
|
||||
None => {
|
||||
return Err(crate::KbError::InvalidState(format!(
|
||||
"cannot record wallet observations for unknown transaction '{}'",
|
||||
signature
|
||||
)));
|
||||
}
|
||||
};
|
||||
let transaction_id = match transaction.id {
|
||||
Some(transaction_id) => transaction_id,
|
||||
None => {
|
||||
return Err(crate::KbError::InvalidState(format!(
|
||||
"transaction '{}' has no internal id",
|
||||
signature
|
||||
)));
|
||||
}
|
||||
};
|
||||
let decoded_events_result = crate::list_dex_decoded_events_by_transaction_id(
|
||||
self.database.as_ref(),
|
||||
transaction_id,
|
||||
)
|
||||
.await;
|
||||
let decoded_events = match decoded_events_result {
|
||||
Ok(decoded_events) => decoded_events,
|
||||
Err(error) => return Err(error),
|
||||
};
|
||||
let mut results = std::vec::Vec::new();
|
||||
for decoded_event in &decoded_events {
|
||||
let decoded_event_id = match decoded_event.id {
|
||||
Some(decoded_event_id) => decoded_event_id,
|
||||
None => {
|
||||
return Err(crate::KbError::InvalidState(
|
||||
"decoded event has no internal id".to_string(),
|
||||
));
|
||||
}
|
||||
};
|
||||
let pool_id = match decoded_event.pool_account.clone() {
|
||||
Some(pool_address) => {
|
||||
let pool_result =
|
||||
crate::get_pool_by_address(self.database.as_ref(), pool_address.as_str())
|
||||
.await;
|
||||
let pool_option = match pool_result {
|
||||
Ok(pool_option) => pool_option,
|
||||
Err(error) => return Err(error),
|
||||
};
|
||||
match pool_option {
|
||||
Some(pool) => pool.id,
|
||||
None => None,
|
||||
}
|
||||
}
|
||||
None => None,
|
||||
};
|
||||
let pair_id = match pool_id {
|
||||
Some(pool_id) => {
|
||||
let pair_result =
|
||||
crate::get_pair_by_pool_id(self.database.as_ref(), pool_id).await;
|
||||
let pair_option = match pair_result {
|
||||
Ok(pair_option) => pair_option,
|
||||
Err(error) => return Err(error),
|
||||
};
|
||||
match pair_option {
|
||||
Some(pair) => pair.id,
|
||||
None => None,
|
||||
}
|
||||
}
|
||||
None => None,
|
||||
};
|
||||
let payload_result =
|
||||
serde_json::from_str::<serde_json::Value>(decoded_event.payload_json.as_str());
|
||||
let payload = match payload_result {
|
||||
Ok(payload) => payload,
|
||||
Err(error) => {
|
||||
return Err(crate::KbError::Json(format!(
|
||||
"cannot parse decoded_event payload_json '{}': {}",
|
||||
decoded_event.payload_json, error
|
||||
)));
|
||||
}
|
||||
};
|
||||
let observed_roles = kb_collect_wallet_roles(&payload);
|
||||
for (role, wallet_address) in observed_roles {
|
||||
let wallet_result =
|
||||
crate::get_wallet_by_address(self.database.as_ref(), wallet_address.as_str())
|
||||
.await;
|
||||
let wallet_option = match wallet_result {
|
||||
Ok(wallet_option) => wallet_option,
|
||||
Err(error) => return Err(error),
|
||||
};
|
||||
let wallet_id = match wallet_option {
|
||||
Some(existing) => match existing.id {
|
||||
Some(wallet_id) => {
|
||||
let dto = crate::KbWalletDto::new(
|
||||
wallet_address.clone(),
|
||||
existing.label.clone(),
|
||||
);
|
||||
let upsert_result =
|
||||
crate::upsert_wallet(self.database.as_ref(), &dto).await;
|
||||
match upsert_result {
|
||||
Ok(_) => wallet_id,
|
||||
Err(error) => return Err(error),
|
||||
}
|
||||
}
|
||||
None => {
|
||||
return Err(crate::KbError::InvalidState(
|
||||
"wallet has no internal id".to_string(),
|
||||
));
|
||||
}
|
||||
},
|
||||
None => {
|
||||
let dto = crate::KbWalletDto::new(wallet_address.clone(), None);
|
||||
let upsert_result =
|
||||
crate::upsert_wallet(self.database.as_ref(), &dto).await;
|
||||
match upsert_result {
|
||||
Ok(wallet_id) => wallet_id,
|
||||
Err(error) => return Err(error),
|
||||
}
|
||||
}
|
||||
};
|
||||
let participation_dto = crate::KbWalletParticipationDto::new(
|
||||
wallet_id,
|
||||
transaction_id,
|
||||
Some(decoded_event_id),
|
||||
pool_id,
|
||||
pair_id,
|
||||
role.clone(),
|
||||
crate::KbObservationSourceKind::HttpRpc,
|
||||
transaction.source_endpoint_name.clone(),
|
||||
);
|
||||
let existing_participation_result = crate::get_wallet_participation_by_unique_key(
|
||||
self.database.as_ref(),
|
||||
participation_dto.unique_key.as_str(),
|
||||
)
|
||||
.await;
|
||||
let existing_participation_option = match existing_participation_result {
|
||||
Ok(existing_participation_option) => existing_participation_option,
|
||||
Err(error) => return Err(error),
|
||||
};
|
||||
let created_participation = existing_participation_option.is_none();
|
||||
let participation_id_result =
|
||||
crate::upsert_wallet_participation(self.database.as_ref(), &participation_dto)
|
||||
.await;
|
||||
let wallet_participation_id = match participation_id_result {
|
||||
Ok(wallet_participation_id) => wallet_participation_id,
|
||||
Err(error) => return Err(error),
|
||||
};
|
||||
if created_participation {
|
||||
let payload = serde_json::json!({
|
||||
"walletAddress": wallet_address,
|
||||
"role": role,
|
||||
"protocolName": decoded_event.protocol_name,
|
||||
"eventKind": decoded_event.event_kind,
|
||||
"poolId": pool_id,
|
||||
"pairId": pair_id,
|
||||
"transactionSignature": transaction.signature
|
||||
});
|
||||
let observation_result = self
|
||||
.persistence
|
||||
.record_observation(&crate::KbDetectionObservationInput::new(
|
||||
"wallet.participation".to_string(),
|
||||
crate::KbObservationSourceKind::HttpRpc,
|
||||
transaction.source_endpoint_name.clone(),
|
||||
transaction.signature.clone(),
|
||||
transaction.slot,
|
||||
payload.clone(),
|
||||
))
|
||||
.await;
|
||||
let observation_id = match observation_result {
|
||||
Ok(observation_id) => observation_id,
|
||||
Err(error) => return Err(error),
|
||||
};
|
||||
let signal_result = self
|
||||
.persistence
|
||||
.record_signal(&crate::KbDetectionSignalInput::new(
|
||||
"signal.wallet.participation.observed".to_string(),
|
||||
crate::KbAnalysisSignalSeverity::Low,
|
||||
transaction.signature.clone(),
|
||||
Some(observation_id),
|
||||
None,
|
||||
payload,
|
||||
))
|
||||
.await;
|
||||
if let Err(error) = signal_result {
|
||||
return Err(error);
|
||||
}
|
||||
}
|
||||
results.push(crate::KbWalletObservationResult {
|
||||
wallet_id,
|
||||
wallet_address,
|
||||
wallet_participation_id,
|
||||
role,
|
||||
pool_id,
|
||||
pair_id,
|
||||
created_participation,
|
||||
});
|
||||
}
|
||||
}
|
||||
Ok(results)
|
||||
}
|
||||
}
|
||||
|
||||
fn kb_collect_wallet_roles(
|
||||
payload: &serde_json::Value,
|
||||
) -> std::vec::Vec<(std::string::String, std::string::String)> {
|
||||
let role_mappings = [
|
||||
("creator", vec!["creator", "poolCreator"]),
|
||||
("payer", vec!["payer", "funder"]),
|
||||
("owner", vec!["owner"]),
|
||||
("user", vec!["user"]),
|
||||
];
|
||||
let mut seen = std::collections::HashSet::<std::string::String>::new();
|
||||
let mut results = std::vec::Vec::new();
|
||||
for (role, keys) in role_mappings {
|
||||
let addresses = kb_extract_strings_for_candidate_keys(payload, &keys);
|
||||
for address in addresses {
|
||||
let dedupe_key = format!("{}:{}", role, address);
|
||||
if seen.contains(&dedupe_key) {
|
||||
continue;
|
||||
}
|
||||
seen.insert(dedupe_key);
|
||||
results.push((role.to_string(), address));
|
||||
}
|
||||
}
|
||||
results
|
||||
}
|
||||
|
||||
fn kb_extract_strings_for_candidate_keys(
|
||||
value: &serde_json::Value,
|
||||
candidate_keys: &[&str],
|
||||
) -> std::vec::Vec<std::string::String> {
|
||||
let mut values = std::vec::Vec::new();
|
||||
kb_extract_strings_for_candidate_keys_inner(value, candidate_keys, &mut values);
|
||||
values
|
||||
}
|
||||
|
||||
fn kb_extract_strings_for_candidate_keys_inner(
|
||||
value: &serde_json::Value,
|
||||
candidate_keys: &[&str],
|
||||
values: &mut std::vec::Vec<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 text_option = direct.as_str();
|
||||
if let Some(text) = text_option {
|
||||
values.push(text.to_string());
|
||||
}
|
||||
}
|
||||
}
|
||||
for nested_value in object.values() {
|
||||
kb_extract_strings_for_candidate_keys_inner(nested_value, candidate_keys, values);
|
||||
}
|
||||
return;
|
||||
}
|
||||
if let Some(array) = value.as_array() {
|
||||
for nested_value in array {
|
||||
kb_extract_strings_for_candidate_keys_inner(nested_value, candidate_keys, values);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
async fn make_database() -> std::sync::Arc<crate::KbDatabase> {
|
||||
let tempdir_result = tempfile::tempdir();
|
||||
let tempdir = match tempdir_result {
|
||||
Ok(tempdir) => tempdir,
|
||||
Err(error) => panic!("tempdir must succeed: {}", error),
|
||||
};
|
||||
let database_path = tempdir.path().join("wallet_observation.sqlite3");
|
||||
let config = crate::KbDatabaseConfig {
|
||||
enabled: true,
|
||||
backend: crate::KbDatabaseBackend::Sqlite,
|
||||
sqlite: crate::KbSqliteDatabaseConfig {
|
||||
path: database_path.to_string_lossy().to_string(),
|
||||
create_if_missing: true,
|
||||
busy_timeout_ms: 5000,
|
||||
max_connections: 1,
|
||||
auto_initialize_schema: true,
|
||||
use_wal: true,
|
||||
},
|
||||
};
|
||||
let database_result = crate::KbDatabase::connect_and_initialize(&config).await;
|
||||
let database = match database_result {
|
||||
Ok(database) => database,
|
||||
Err(error) => panic!("database init must succeed: {}", error),
|
||||
};
|
||||
std::sync::Arc::new(database)
|
||||
}
|
||||
|
||||
async fn seed_fluxbeam_transaction(
|
||||
database: std::sync::Arc<crate::KbDatabase>,
|
||||
signature: &str,
|
||||
) {
|
||||
let transaction_model = crate::KbTransactionModelService::new(database.clone());
|
||||
let dex_decode = crate::KbDexDecodeService::new(database.clone());
|
||||
let dex_detect = crate::KbDexDetectService::new(database);
|
||||
let resolved_transaction = serde_json::json!({
|
||||
"slot": 930001,
|
||||
"blockTime": 1779300001,
|
||||
"version": 0,
|
||||
"transaction": {
|
||||
"message": {
|
||||
"instructions": [
|
||||
{
|
||||
"programId": crate::KB_FLUXBEAM_PROGRAM_ID,
|
||||
"program": "fluxbeam",
|
||||
"stackHeight": 1,
|
||||
"accounts": [
|
||||
"WalletObsPool111",
|
||||
"WalletObsLpMint111",
|
||||
"WalletObsTokenA111",
|
||||
"So11111111111111111111111111111111111111112",
|
||||
"WalletObserved111"
|
||||
],
|
||||
"parsed": {
|
||||
"info": {
|
||||
"instruction": "create_pool",
|
||||
"pool": "WalletObsPool111",
|
||||
"lpMint": "WalletObsLpMint111",
|
||||
"tokenA": "WalletObsTokenA111",
|
||||
"tokenB": "So11111111111111111111111111111111111111112",
|
||||
"payer": "WalletObserved111"
|
||||
}
|
||||
},
|
||||
"data": "opaque"
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
"meta": {
|
||||
"err": null,
|
||||
"logMessages": [
|
||||
"Program log: Instruction: CreatePool"
|
||||
]
|
||||
}
|
||||
});
|
||||
let project_result = transaction_model
|
||||
.persist_resolved_transaction(
|
||||
signature,
|
||||
Some("helius_primary_http".to_string()),
|
||||
&resolved_transaction,
|
||||
)
|
||||
.await;
|
||||
if let Err(error) = project_result {
|
||||
panic!("projection must succeed: {}", error);
|
||||
}
|
||||
let decode_result = dex_decode.decode_transaction_by_signature(signature).await;
|
||||
if let Err(error) = decode_result {
|
||||
panic!("dex decode must succeed: {}", error);
|
||||
}
|
||||
let detect_result = dex_detect.detect_transaction_by_signature(signature).await;
|
||||
if let Err(error) = detect_result {
|
||||
panic!("dex detect must succeed: {}", error);
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn record_transaction_by_signature_creates_wallet_and_participations() {
|
||||
let database = make_database().await;
|
||||
seed_fluxbeam_transaction(database.clone(), "sig-wallet-observation-1").await;
|
||||
let service = crate::KbWalletObservationService::new(database.clone());
|
||||
let record_result = service
|
||||
.record_transaction_by_signature("sig-wallet-observation-1")
|
||||
.await;
|
||||
let results = match record_result {
|
||||
Ok(results) => results,
|
||||
Err(error) => panic!("wallet observation must succeed: {}", error),
|
||||
};
|
||||
assert_eq!(results.len(), 2);
|
||||
let wallets_result = crate::list_wallets(database.as_ref()).await;
|
||||
let wallets = match wallets_result {
|
||||
Ok(wallets) => wallets,
|
||||
Err(error) => panic!("wallet list must succeed: {}", error),
|
||||
};
|
||||
assert_eq!(wallets.len(), 1);
|
||||
let wallet = &wallets[0];
|
||||
let wallet_id = match wallet.id {
|
||||
Some(wallet_id) => wallet_id,
|
||||
None => panic!("wallet must have an id"),
|
||||
};
|
||||
let participations_result =
|
||||
crate::list_wallet_participations_by_wallet_id(database.as_ref(), wallet_id).await;
|
||||
let participations = match participations_result {
|
||||
Ok(participations) => participations,
|
||||
Err(error) => panic!("participation list must succeed: {}", error),
|
||||
};
|
||||
assert_eq!(participations.len(), 2);
|
||||
let mut roles = std::vec::Vec::new();
|
||||
for participation in &participations {
|
||||
roles.push(participation.role.clone());
|
||||
}
|
||||
roles.sort();
|
||||
assert_eq!(roles, vec!["creator".to_string(), "payer".to_string()]);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn record_transaction_by_signature_is_idempotent() {
|
||||
let database = make_database().await;
|
||||
seed_fluxbeam_transaction(database.clone(), "sig-wallet-observation-2").await;
|
||||
let service = crate::KbWalletObservationService::new(database.clone());
|
||||
let first_result = service
|
||||
.record_transaction_by_signature("sig-wallet-observation-2")
|
||||
.await;
|
||||
let first_results = match first_result {
|
||||
Ok(first_results) => first_results,
|
||||
Err(error) => panic!("first wallet observation must succeed: {}", error),
|
||||
};
|
||||
assert_eq!(first_results.len(), 2);
|
||||
assert!(first_results[0].created_participation);
|
||||
assert!(first_results[1].created_participation);
|
||||
let second_result = service
|
||||
.record_transaction_by_signature("sig-wallet-observation-2")
|
||||
.await;
|
||||
let second_results = match second_result {
|
||||
Ok(second_results) => second_results,
|
||||
Err(error) => panic!("second wallet observation must succeed: {}", error),
|
||||
};
|
||||
assert_eq!(second_results.len(), 2);
|
||||
assert!(!second_results[0].created_participation);
|
||||
assert!(!second_results[1].created_participation);
|
||||
let wallets_result = crate::list_wallets(database.as_ref()).await;
|
||||
let wallets = match wallets_result {
|
||||
Ok(wallets) => wallets,
|
||||
Err(error) => panic!("wallet list must succeed: {}", error),
|
||||
};
|
||||
assert_eq!(wallets.len(), 1);
|
||||
let wallet_id = wallets[0].id.unwrap_or_default();
|
||||
let participations_result =
|
||||
crate::list_wallet_participations_by_wallet_id(database.as_ref(), wallet_id).await;
|
||||
let participations = match participations_result {
|
||||
Ok(participations) => participations,
|
||||
Err(error) => panic!("participation list must succeed: {}", error),
|
||||
};
|
||||
assert_eq!(participations.len(), 2);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user