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

0.7.21

Browse Source
This commit is contained in:
SinuS von SifriduS
2026-04-30 12:37:01 +02:00
parent 37d54887d6
commit b3b0e882b2
14 changed files with 1324 additions and 9 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
kb_lib/src/db/dtos.rs
View File

@@ -19,6 +19,7 @@ mod liquidity_event;
mod observed_token;
mod onchain_observation;
mod pair;
mod pair_analytic_signal;
mod pair_candle;
mod pair_metric;
mod pool;
@@ -51,6 +52,7 @@ pub use liquidity_event::KbLiquidityEventDto;
pub use observed_token::KbObservedTokenDto;
pub use onchain_observation::KbOnchainObservationDto;
pub use pair::KbPairDto;
pub use pair_analytic_signal::KbPairAnalyticSignalDto;
pub use pair_candle::KbPairCandleDto;
pub use pair_metric::KbPairMetricDto;
pub use pool::KbPoolDto;

120
kb_lib/src/db/dtos/pair_analytic_signal.rs Normal file
View File

@@ -0,0 +1,120 @@
// file: kb_lib/src/db/dtos/pair_analytic_signal.rs
//! Pair-analytic-signal DTO.
/// Application-facing pair-analytic-signal DTO.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct KbPairAnalyticSignalDto {
/// Optional numeric primary key.
pub id: std::option::Option<i64>,
/// Related pair id.
pub pair_id: i64,
/// Stable signal kind.
pub signal_kind: std::string::String,
/// Signal severity.
pub severity: crate::KbAnalysisSignalSeverity,
/// Timeframe in seconds. Zero means non-bucketed signal.
pub timeframe_seconds: i64,
/// Inclusive bucket start in unix seconds. Zero means non-bucketed signal.
pub bucket_start_unix: i64,
/// Optional numeric score.
pub score: std::option::Option<f64>,
/// Signal value payload.
pub signal_value: serde_json::Value,
/// Optional first transaction id that produced this signal key.
pub first_transaction_id: std::option::Option<i64>,
/// Optional last transaction id that produced this signal key.
pub last_transaction_id: std::option::Option<i64>,
/// Creation timestamp.
pub created_at: chrono::DateTime<chrono::Utc>,
/// Update timestamp.
pub updated_at: chrono::DateTime<chrono::Utc>,
}
impl KbPairAnalyticSignalDto {
/// Creates a new pair-analytic-signal DTO.
pub fn new(
pair_id: i64,
signal_kind: std::string::String,
severity: crate::KbAnalysisSignalSeverity,
timeframe_seconds: i64,
bucket_start_unix: i64,
score: std::option::Option<f64>,
signal_value: serde_json::Value,
first_transaction_id: std::option::Option<i64>,
last_transaction_id: std::option::Option<i64>,
) -> Self {
let now = chrono::Utc::now();
Self {
id: None,
pair_id,
signal_kind,
severity,
timeframe_seconds,
bucket_start_unix,
score,
signal_value,
first_transaction_id,
last_transaction_id,
created_at: now,
updated_at: now,
}
}
}
impl TryFrom<crate::KbPairAnalyticSignalEntity> for KbPairAnalyticSignalDto {
type Error = crate::KbError;
fn try_from(entity: crate::KbPairAnalyticSignalEntity) -> Result<Self, Self::Error> {
let severity_result = crate::KbAnalysisSignalSeverity::from_i16(entity.severity);
let severity = match severity_result {
Ok(severity) => severity,
Err(error) => return Err(error),
};
let signal_value_result =
serde_json::from_str::<serde_json::Value>(entity.signal_value_json.as_str());
let signal_value = match signal_value_result {
Ok(signal_value) => signal_value,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot parse pair_analytic_signal signal_value_json '{}': {}",
entity.signal_value_json, error
)));
}
};
let created_at_result = chrono::DateTime::parse_from_rfc3339(entity.created_at.as_str());
let created_at = match created_at_result {
Ok(created_at) => created_at.with_timezone(&chrono::Utc),
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot parse pair_analytic_signal created_at '{}': {}",
entity.created_at, error
)));
}
};
let updated_at_result = chrono::DateTime::parse_from_rfc3339(entity.updated_at.as_str());
let updated_at = match updated_at_result {
Ok(updated_at) => updated_at.with_timezone(&chrono::Utc),
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot parse pair_analytic_signal updated_at '{}': {}",
entity.updated_at, error
)));
}
};
Ok(Self {
id: Some(entity.id),
pair_id: entity.pair_id,
signal_kind: entity.signal_kind,
severity,
timeframe_seconds: entity.timeframe_seconds,
bucket_start_unix: entity.bucket_start_unix,
score: entity.score,
signal_value,
first_transaction_id: entity.first_transaction_id,
last_transaction_id: entity.last_transaction_id,
created_at,
updated_at,
})
}
}

2
kb_lib/src/db/entities.rs
View File

@@ -21,6 +21,7 @@ mod liquidity_event;
mod observed_token;
mod onchain_observation;
mod pair;
mod pair_analytic_signal;
mod pair_candle;
mod pair_metric;
mod pool;
@@ -53,6 +54,7 @@ pub use liquidity_event::KbLiquidityEventEntity;
pub use observed_token::KbObservedTokenEntity;
pub use onchain_observation::KbOnchainObservationEntity;
pub use pair::KbPairEntity;
pub use pair_analytic_signal::KbPairAnalyticSignalEntity;
pub use pair_candle::KbPairCandleEntity;
pub use pair_metric::KbPairMetricEntity;
pub use pool::KbPoolEntity;

32
kb_lib/src/db/entities/pair_analytic_signal.rs Normal file
View File

@@ -0,0 +1,32 @@
// file: kb_lib/src/db/entities/pair_analytic_signal.rs
//! Pair-analytic-signal entity.
/// Persisted pair-analytic-signal row.
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, sqlx::FromRow)]
pub struct KbPairAnalyticSignalEntity {
/// Numeric primary key.
pub id: i64,
/// Related pair id.
pub pair_id: i64,
/// Stable signal kind.
pub signal_kind: std::string::String,
/// Signal severity.
pub severity: i16,
/// Timeframe in seconds. Zero means non-bucketed signal.
pub timeframe_seconds: i64,
/// Inclusive bucket start in unix seconds. Zero means non-bucketed signal.
pub bucket_start_unix: i64,
/// Optional numeric score.
pub score: std::option::Option<f64>,
/// Signal value JSON encoded as text.
pub signal_value_json: std::string::String,
/// Optional first transaction id that produced this signal key.
pub first_transaction_id: std::option::Option<i64>,
/// Optional last transaction id that produced this signal key.
pub last_transaction_id: std::option::Option<i64>,
/// Creation timestamp encoded as RFC3339 UTC text.
pub created_at: std::string::String,
/// Update timestamp encoded as RFC3339 UTC text.
pub updated_at: std::string::String,
}

4
kb_lib/src/db/queries.rs
View File

@@ -23,6 +23,7 @@ mod liquidity_event;
mod observed_token;
mod onchain_observation;
mod pair;
mod pair_analytic_signal;
mod pair_candle;
mod pair_metric;
mod pool;
@@ -85,6 +86,9 @@ pub use onchain_observation::list_recent_onchain_observations;
pub use pair::get_pair_by_pool_id;
pub use pair::list_pairs;
pub use pair::upsert_pair;
pub use pair_analytic_signal::get_pair_analytic_signal_by_key;
pub use pair_analytic_signal::list_pair_analytic_signals_by_pair_id;
pub use pair_analytic_signal::upsert_pair_analytic_signal;
pub use pair_candle::get_pair_candle_by_key;
pub use pair_candle::list_pair_candles_by_pair_and_timeframe;
pub use pair_candle::upsert_pair_candle;

196
kb_lib/src/db/queries/pair_analytic_signal.rs Normal file
View File

@@ -0,0 +1,196 @@
// file: kb_lib/src/db/queries/pair_analytic_signal.rs
//! Queries for `kb_pair_analytic_signals`.
/// Inserts or updates one pair-analytic-signal row and returns its stable internal id.
pub async fn upsert_pair_analytic_signal(
database: &crate::KbDatabase,
dto: &crate::KbPairAnalyticSignalDto,
) -> Result<i64, crate::KbError> {
let signal_value_json_result = serde_json::to_string(&dto.signal_value);
let signal_value_json = match signal_value_json_result {
Ok(signal_value_json) => signal_value_json,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot serialize pair analytic signal payload: {}",
error
)));
}
};
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_pair_analytic_signals (
pair_id,
signal_kind,
severity,
timeframe_seconds,
bucket_start_unix,
score,
signal_value_json,
first_transaction_id,
last_transaction_id,
created_at,
updated_at
)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
ON CONFLICT(pair_id, signal_kind, timeframe_seconds, bucket_start_unix) DO UPDATE SET
severity = excluded.severity,
score = excluded.score,
signal_value_json = excluded.signal_value_json,
last_transaction_id = excluded.last_transaction_id,
updated_at = excluded.updated_at
"#,
)
.bind(dto.pair_id)
.bind(dto.signal_kind.clone())
.bind(dto.severity.to_i16())
.bind(dto.timeframe_seconds)
.bind(dto.bucket_start_unix)
.bind(dto.score)
.bind(signal_value_json)
.bind(dto.first_transaction_id)
.bind(dto.last_transaction_id)
.bind(dto.created_at.to_rfc3339())
.bind(dto.updated_at.to_rfc3339())
.execute(pool)
.await;
if let Err(error) = query_result {
return Err(crate::KbError::Db(format!(
"cannot upsert kb_pair_analytic_signals on sqlite: {}",
error
)));
}
let id_result = sqlx::query_scalar::<sqlx::Sqlite, i64>(
r#"
SELECT id
FROM kb_pair_analytic_signals
WHERE pair_id = ? AND signal_kind = ? AND timeframe_seconds = ? AND bucket_start_unix = ?
LIMIT 1
"#,
)
.bind(dto.pair_id)
.bind(dto.signal_kind.clone())
.bind(dto.timeframe_seconds)
.bind(dto.bucket_start_unix)
.fetch_one(pool)
.await;
match id_result {
Ok(id) => Ok(id),
Err(error) => Err(crate::KbError::Db(format!(
"cannot fetch kb_pair_analytic_signals id on sqlite: {}",
error
))),
}
}
}
}
/// Returns one pair-analytic-signal row identified by its key, if it exists.
pub async fn get_pair_analytic_signal_by_key(
database: &crate::KbDatabase,
pair_id: i64,
signal_kind: &str,
timeframe_seconds: i64,
bucket_start_unix: i64,
) -> Result<std::option::Option<crate::KbPairAnalyticSignalDto>, crate::KbError> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result =
sqlx::query_as::<sqlx::Sqlite, crate::KbPairAnalyticSignalEntity>(
r#"
SELECT
id,
pair_id,
signal_kind,
severity,
timeframe_seconds,
bucket_start_unix,
score,
signal_value_json,
first_transaction_id,
last_transaction_id,
created_at,
updated_at
FROM kb_pair_analytic_signals
WHERE pair_id = ? AND signal_kind = ? AND timeframe_seconds = ? AND bucket_start_unix = ?
LIMIT 1
"#,
)
.bind(pair_id)
.bind(signal_kind)
.bind(timeframe_seconds)
.bind(bucket_start_unix)
.fetch_optional(pool)
.await;
let entity_option = match query_result {
Ok(entity_option) => entity_option,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot read kb_pair_analytic_signals by key on sqlite: {}",
error
)));
}
};
match entity_option {
Some(entity) => crate::KbPairAnalyticSignalDto::try_from(entity).map(Some),
None => Ok(None),
}
}
}
}
/// Lists all pair-analytic signals for one pair ordered by key.
pub async fn list_pair_analytic_signals_by_pair_id(
database: &crate::KbDatabase,
pair_id: i64,
) -> Result<std::vec::Vec<crate::KbPairAnalyticSignalDto>, crate::KbError> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result =
sqlx::query_as::<sqlx::Sqlite, crate::KbPairAnalyticSignalEntity>(
r#"
SELECT
id,
pair_id,
signal_kind,
severity,
timeframe_seconds,
bucket_start_unix,
score,
signal_value_json,
first_transaction_id,
last_transaction_id,
created_at,
updated_at
FROM kb_pair_analytic_signals
WHERE pair_id = ?
ORDER BY timeframe_seconds ASC, bucket_start_unix ASC, signal_kind ASC, id ASC
"#,
)
.bind(pair_id)
.fetch_all(pool)
.await;
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_pair_analytic_signals by pair_id '{}' on sqlite: {}",
pair_id, error
)));
}
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbPairAnalyticSignalDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),
};
dtos.push(dto);
}
Ok(dtos)
}
}
}

52
kb_lib/src/db/schema.rs
View File

@@ -334,6 +334,14 @@ pub(crate) async fn ensure_schema(database: &crate::KbDatabase) -> Result<(), cr
if let Err(error) = result {
return Err(error);
}
let result = create_kb_pair_analytic_signals_table(pool).await;
if let Err(error) = result {
return Err(error);
}
let result = create_kb_idx_pair_analytic_signals_pair_id(pool).await;
if let Err(error) = result {
return Err(error);
}
Ok(())
}
}
@@ -1858,3 +1866,47 @@ ON kb_pair_candles(bucket_start_unix)
)
.await
}
async fn create_kb_pair_analytic_signals_table(
pool: &sqlx::SqlitePool,
) -> Result<(), crate::KbError> {
execute_sqlite_schema_statement(
pool,
"create_kb_pair_analytic_signals_table",
r#"
CREATE TABLE IF NOT EXISTS kb_pair_analytic_signals (
id INTEGER PRIMARY KEY AUTOINCREMENT,
pair_id INTEGER NOT NULL,
signal_kind TEXT NOT NULL,
severity INTEGER NOT NULL,
timeframe_seconds INTEGER NOT NULL,
bucket_start_unix INTEGER NOT NULL,
score REAL NULL,
signal_value_json TEXT NOT NULL,
first_transaction_id INTEGER NULL,
last_transaction_id INTEGER NULL,
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL,
UNIQUE(pair_id, signal_kind, timeframe_seconds, bucket_start_unix),
FOREIGN KEY(pair_id) REFERENCES kb_pairs(id) ON DELETE CASCADE,
FOREIGN KEY(first_transaction_id) REFERENCES kb_chain_transactions(id) ON DELETE SET NULL,
FOREIGN KEY(last_transaction_id) REFERENCES kb_chain_transactions(id) ON DELETE SET NULL
)
"#,
)
.await
}
async fn create_kb_idx_pair_analytic_signals_pair_id(
pool: &sqlx::SqlitePool,
) -> Result<(), crate::KbError> {
execute_sqlite_schema_statement(
pool,
"create_kb_idx_pair_analytic_signals_pair_id",
r#"
CREATE INDEX IF NOT EXISTS kb_idx_pair_analytic_signals_pair_id
ON kb_pair_analytic_signals(pair_id)
"#,
)
.await
}