From e98fe36e52787d60a506d9932d5e918de9652b14 Mon Sep 17 00:00:00 2001 From: Amir Abdin Date: Fri, 22 Sep 2023 15:01:57 +0200 Subject: [PATCH 01/12] trivial commit --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index b05dc85..13c483a 100644 --- a/README.md +++ b/README.md @@ -1 +1 @@ -# cardano-data-provider \ No newline at end of file +# cardano-data-provider \ No newline at end of file From 892293ae0d6d34be135d32091fa79b9a73bd3cd7 Mon Sep 17 00:00:00 2001 From: Amir Abdin Date: Sat, 23 Sep 2023 22:58:42 +0200 Subject: [PATCH 02/12] Add Pool endpoints --- src/blockfrost/api.rs | 114 ++++++ src/blockfrost/mod.rs | 113 ++++++ src/carb/api.rs | 113 ++++++ src/carb/mod.rs | 114 ++++++ src/dbsync/api.rs | 501 ++++++++++++++++++++++++ src/dbsync/mod.rs | 113 ++++++ src/dbsync/models.rs | 2 +- src/dbsync/schema.rs | 2 +- src/koios/api.rs | 113 ++++++ src/koios/mod.rs | 113 ++++++ src/provider/mod.rs | 192 +++++++++ src/server/handler/handler_rest/info.rs | 354 +++++++++++++++++ src/server/handler/handler_rest/mod.rs | 21 +- 13 files changed, 1862 insertions(+), 3 deletions(-) diff --git a/src/blockfrost/api.rs b/src/blockfrost/api.rs index 501c08d..e4c64e2 100644 --- a/src/blockfrost/api.rs +++ b/src/blockfrost/api.rs @@ -9,6 +9,7 @@ use crate::models::{ use crate::provider::error::DataProviderError; use blockfrost::{AccountAddress, AddressUtxo}; use bigdecimal::BigDecimal; +use serde_json::{json, Value}; /// get all tokens of an utxo pub fn get_utxo_tokens( @@ -256,3 +257,116 @@ pub fn retrieve_generated_rewards ( ) -> Result, DataProviderError> { Ok(vec![]) } + + +pub fn pool_vrf_key_hash ( + bfp: &BlockfrostProvider, + pool_hash: &str, +) -> Result, DataProviderError> { + Ok(vec![]) +} + +pub fn pool_blocks_minted ( + bfp: &BlockfrostProvider, + pool_hash: &str, +) -> Result { + Ok(0) +} + +pub fn pool_blocks_current_epoch( + bfp: &BlockfrostProvider, + pool_hash: &str, +) -> Result { + Ok(0) +} + +pub fn pool_declared_pledge( + bfp: &BlockfrostProvider, + pool_hash: &str, +) -> Result { + Ok(BigDecimal::from(0)) +} + +pub fn pool_margin_cost( + bfp: &BlockfrostProvider, + pool_hash: &str, +) -> Result { + Ok(0.0) +} + +pub fn pool_fixed_cost( + bfp: &BlockfrostProvider, + pool_hash: &str, +) -> Result { + Ok(BigDecimal::from(0)) +} + +pub fn pool_reward_address( + bfp: &BlockfrostProvider, + pool_hash: &str, +) -> Result { + Ok("".to_string()) +} + +pub fn pool_owner( + bfp: &BlockfrostProvider, + pool_hash: &str, +) -> Result { + Ok("".to_string()) +} + +pub fn pool_registration( + bfp: &BlockfrostProvider, + pool_hash: &str, +) -> Result { + Ok(0) +} + +pub fn pool_retirement( + bfp: &BlockfrostProvider, + pool_hash: &str, +) -> Result { + Ok(0) +} + +pub fn pool_url( + bfp: &BlockfrostProvider, + pool_hash: &str, +) -> Result { + Ok("".to_string()) +} + +pub fn pool_ticker( + bfp: &BlockfrostProvider, + pool_hash: &str, +) -> Result { + Ok("".to_string()) +} + +pub fn pool_metadata_json( + bfp: &BlockfrostProvider, + pool_hash: &str, +) -> Result { + Ok(json!({})) +} + +pub fn pool_name( + bfp: &BlockfrostProvider, + pool_hash: &str, +) -> Result { + Ok("".to_string()) +} + +pub fn pool_homepage( + bfp: &BlockfrostProvider, + pool_hash: &str, +) -> Result { + Ok("".to_string()) +} + +pub fn pool_description( + bfp: &BlockfrostProvider, + pool_hash: &str, +) -> Result { + Ok("".to_string()) +} \ No newline at end of file diff --git a/src/blockfrost/mod.rs b/src/blockfrost/mod.rs index 0e015df..ed470a8 100644 --- a/src/blockfrost/mod.rs +++ b/src/blockfrost/mod.rs @@ -6,6 +6,7 @@ use crate::models::{CDPDatum, RewardView, TokenInfoView, CardanoNativeAssetView, use async_trait::async_trait; use blockfrost::{load, BlockFrostApi}; use bigdecimal::BigDecimal; +use serde_json::Value; pub mod api; pub mod error; @@ -267,4 +268,116 @@ impl super::provider::CardanoDataProvider for BlockfrostProvider { ) -> Result, DataProviderError> { Ok(api::retrieve_generated_rewards(self, stake_addr)?) } + + async fn pool_vrf_key_hash ( + &self, + pool_hash: &str, + ) -> Result, DataProviderError> { + Ok(api::pool_vrf_key_hash(self, pool_hash)?) + } + + async fn pool_blocks_minted ( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_blocks_minted(self, pool_hash)?) + } + + async fn pool_blocks_current_epoch( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_blocks_current_epoch(self, pool_hash)?) + } + + async fn pool_declared_pledge( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_declared_pledge(self, pool_hash)?) + } + + async fn pool_margin_cost( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_margin_cost(self, pool_hash)?) + } + + async fn pool_fixed_cost( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_fixed_cost(self, pool_hash)?) + } + + async fn pool_reward_address( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_reward_address(self, pool_hash)?) + } + + async fn pool_owner( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_owner(self, pool_hash)?) + } + + async fn pool_registration( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_registration(self, pool_hash)?) + } + + async fn pool_retirement( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_retirement(self, pool_hash)?) + } + + async fn pool_url( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_url(self, pool_hash)?) + } + + async fn pool_ticker( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_ticker(self, pool_hash)?) + } + + async fn pool_metadata_json( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_metadata_json(self, pool_hash)?) + } + + async fn pool_name( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_name(self, pool_hash)?) + } + + async fn pool_homepage( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_homepage(self, pool_hash)?) + } + + async fn pool_description( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_description(self, pool_hash)?) + } } diff --git a/src/carb/api.rs b/src/carb/api.rs index 6fff616..0da4e6a 100644 --- a/src/carb/api.rs +++ b/src/carb/api.rs @@ -7,6 +7,7 @@ use crate::models::{ use crate::provider::error::DataProviderError; use bigdecimal::BigDecimal; +use serde_json::{Value, json}; /// get all tokens of an utxo pub fn get_utxo_tokens( @@ -198,3 +199,115 @@ pub fn retrieve_generated_rewards ( ) -> Result, DataProviderError> { Ok(vec![]) } + +pub fn pool_vrf_key_hash ( + bfp: &CarbProvider, + pool_hash: &str, +) -> Result, DataProviderError> { + Ok(vec![]) +} + +pub fn pool_blocks_minted ( + bfp: &CarbProvider, + pool_hash: &str, +) -> Result { + Ok(0) +} + +pub fn pool_blocks_current_epoch( + bfp: &CarbProvider, + pool_hash: &str, +) -> Result { + Ok(0) +} + +pub fn pool_declared_pledge( + bfp: &CarbProvider, + pool_hash: &str, +) -> Result { + Ok(BigDecimal::from(0)) +} + +pub fn pool_margin_cost ( + bfp: &CarbProvider, + pool_hash: &str, +) -> Result { + Ok(0.0) +} + +pub fn pool_fixed_cost( + bfp: &CarbProvider, + pool_hash: &str, +) -> Result { + Ok(BigDecimal::from(0)) +} + +pub fn pool_reward_address( + bfp: &CarbProvider, + pool_hash: &str, +) -> Result { + Ok("".to_string()) +} + +pub fn pool_owner( + bfp: &CarbProvider, + pool_hash: &str, +) -> Result { + Ok("".to_string()) +} + +pub fn pool_registration( + bfp: &CarbProvider, + pool_hash: &str, +) -> Result { + Ok(0) +} + +pub fn pool_retirement( + bfp: &CarbProvider, + pool_hash: &str, +) -> Result { + Ok(0) +} + +pub fn pool_url( + bfp: &CarbProvider, + pool_hash: &str, +) -> Result { + Ok("".to_string()) +} + +pub fn pool_ticker( + bfp: &CarbProvider, + pool_hash: &str, +) -> Result { + Ok("".to_string()) +} + +pub fn pool_metadata_json( + bfp: &CarbProvider, + pool_hash: &str, +) -> Result { + Ok(json!({})) +} + +pub fn pool_name( + bfp: &CarbProvider, + pool_hash: &str, +) -> Result { + Ok("".to_string()) +} + +pub fn pool_homepage( + bfp: &CarbProvider, + pool_hash: &str, +) -> Result { + Ok("".to_string()) +} + +pub fn pool_description( + bfp: &CarbProvider, + pool_hash: &str, +) -> Result { + Ok("".to_string()) +} \ No newline at end of file diff --git a/src/carb/mod.rs b/src/carb/mod.rs index 5ca3672..0532044 100644 --- a/src/carb/mod.rs +++ b/src/carb/mod.rs @@ -7,6 +7,7 @@ use crate::provider::error::DataProviderError; use self::error::DataProviderCarbError; use async_trait::async_trait; use bigdecimal::BigDecimal; +use serde_json::Value; pub mod api; pub mod error; @@ -255,4 +256,117 @@ impl super::provider::CardanoDataProvider for CarbProvider { ) -> Result, DataProviderError> { Ok(api::retrieve_generated_rewards(self, stake_addr)?) } + + async fn pool_vrf_key_hash ( + &self, + pool_hash: &str, + ) -> Result, DataProviderError> { + Ok(api::pool_vrf_key_hash(self, pool_hash)?) + } + + async fn pool_blocks_minted ( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_blocks_minted(self, pool_hash)?) + } + + async fn pool_blocks_current_epoch( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_blocks_current_epoch(self, pool_hash)?) + } + + async fn pool_declared_pledge( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_declared_pledge(self, pool_hash)?) + } + + async fn pool_margin_cost( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_margin_cost(self, pool_hash)?) + } + + async fn pool_fixed_cost( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_fixed_cost(self, pool_hash)?) + } + + async fn pool_reward_address( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_reward_address(self, pool_hash)?) + } + + async fn pool_owner( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_owner(self, pool_hash)?) + } + + async fn pool_registration( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_registration(self, pool_hash)?) + } + + async fn pool_retirement( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_retirement(self, pool_hash)?) + } + + + async fn pool_url( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_url(self, pool_hash)?) + } + + async fn pool_ticker( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_ticker(self, pool_hash)?) + } + + async fn pool_metadata_json( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_metadata_json(self, pool_hash)?) + } + + async fn pool_name( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_name(self, pool_hash)?) + } + + async fn pool_homepage( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_homepage(self, pool_hash)?) + } + + async fn pool_description( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_description(self, pool_hash)?) + } } diff --git a/src/dbsync/api.rs b/src/dbsync/api.rs index 5b04ba1..1cfef1a 100644 --- a/src/dbsync/api.rs +++ b/src/dbsync/api.rs @@ -13,6 +13,7 @@ use dcslc::TransactionUnspentOutputs; use diesel::prelude::*; use log::debug; use std::str::FromStr; +use serde_json::Value; /// get all tokens of an utxo pub fn get_utxo_tokens( @@ -1827,11 +1828,307 @@ pub async fn epoch_change( Ok(out) } +/// VRF stands for Verifiable Random Function. VRF key hash is generated +/// by VRF private key to ensure that the next slot leader is selected +/// truly at random without possibility to rig the mechanism for selecting +/// slot leaders. +pub async fn pool_vrf_key_hash( + dbs: &DBSyncProvider, + pool_hash: &str, +) -> Result, DataProviderDBSyncError> { + Ok( + pool_update::table + .inner_join(pool_hash::table.on(pool_hash::id.eq(pool_update::hash_id))) + .filter(pool_hash::view.eq(pool_hash.to_string())) + .order(pool_update::active_epoch_no.desc()) + .select(pool_update::vrf_key_hash) + .first::>(&mut dbs.connect()?)? + ) +} + +/// Total number of blocks ever minted by the given stake pool. +pub async fn pool_blocks_minted( + dbs: &DBSyncProvider, + pool_hash: &str, +) -> Result { + Ok( + block::table + .inner_join(slot_leader::table.on(slot_leader::id.eq(block::slot_leader_id))) + .inner_join(pool_hash::table.on(pool_hash::id.nullable().eq(slot_leader::pool_hash_id))) + .filter(pool_hash::view.eq(pool_hash)) + .count() + .get_result::(&mut dbs.connect()?)? + ) +} + +/// The number of blocks minted by the given stake pool in the current epoch. +pub async fn pool_blocks_current_epoch( + dbs: &DBSyncProvider, + pool_hash: &str, +) -> Result { + Ok( + block::table + .inner_join(slot_leader::table.on(slot_leader::id.eq(block::slot_leader_id))) + .inner_join(pool_hash::table.on(pool_hash::id.nullable().eq(slot_leader::pool_hash_id))) + .filter(pool_hash::view.eq(pool_hash)) + .filter(block::epoch_no.is_not_null()) + .filter(block::epoch_no.eq(current_epoch(dbs)?)) + .count() + .get_result::(&mut dbs.connect()?)? + ) +} + +/// The quantity of delegators that are currently delegating +/// to the given stake pool. +pub async fn pool_live_delegators( + dbs: &DBSyncProvider, + pool_hash: &str, +) -> Result { + Ok( + reward::table + .inner_join(pool_hash::table.on(pool_hash::id.nullable().eq(reward::pool_id))) + .filter(pool_hash::view.eq(pool_hash.to_string())) + .filter(reward::earned_epoch.eq(current_epoch(dbs).unwrap() as i64)) + // .filter(reward::type_.eq(Rewardtype::Member)) TODO: FixMe + .count() + .get_result::(&mut dbs.connect().unwrap() + ).unwrap() + ) +} + +/// the amount of Ada that the owner of the given stake pool +/// has pledged to stake in the given pool, according to the +/// pool registration certificate. +pub async fn pool_declared_pledge( + dbs: &DBSyncProvider, + pool_hash: &str, +) -> Result { + Ok( + pool_update::table + .inner_join(pool_hash::table.on(pool_hash::id.eq(pool_update::hash_id))) + .filter(pool_hash::view.eq(pool_hash.to_string())) + .order(pool_update::active_epoch_no.desc()) + .select(pool_update::pledge) + .first::(&mut dbs.connect()?)? + ) +} + +/// The percentage of delegator's Ada rewards that the pool +/// owner will keep for itself as compensation for enabling +/// the delegator to delegate. +pub async fn pool_margin_cost( + dbs: &DBSyncProvider, + pool_hash: &str, +) -> Result { + Ok( + pool_update::table + .inner_join(pool_hash::table.on(pool_hash::id.eq(pool_update::hash_id))) + .filter(pool_hash::view.eq(pool_hash.to_string())) + .order(pool_update::active_epoch_no.desc()) + .select(pool_update::margin) + .first::(&mut dbs.connect()?)? + ) +} + +/// The fixed amount of delegator's Ada rewards that +/// the pool owner will keep for themselves per epoch as +/// compensation for enabling the delegator to delegate. +pub async fn pool_fixed_cost( + dbs: &DBSyncProvider, + pool_hash: &str, +) -> Result { + Ok( + pool_update::table + .inner_join(pool_hash::table.on(pool_hash::id.eq(pool_update::hash_id))) + .filter(pool_hash::view.eq(pool_hash.to_string())) + .order(pool_update::active_epoch_no.desc()) + .select(pool_update::fixed_cost) + .first::(&mut dbs.connect()?)? + ) +} + +/// The stake address on the receiving end of the fixed cost +/// and margin cost payed by the delegators. This is also the +/// pool owner. +pub async fn pool_reward_address( + dbs: &DBSyncProvider, + pool_hash: &str, +) -> Result { + Ok( + pool_update::table + .inner_join(pool_hash::table.on(pool_hash::id.eq(pool_update::hash_id))) + .inner_join(stake_address::table.on(stake_address::id.eq(pool_update::reward_addr_id))) + .filter(pool_hash::view.eq(pool_hash.to_string())) + .order(pool_update::active_epoch_no.desc()) + .select(stake_address::view) + .first::(&mut dbs.connect()?)? + ) +} + +/// The stake address that owns the given stake pool. This +/// address is on the receiving end of fixed cost and margin +/// cost paid by the delegators. +pub async fn pool_owner( + dbs: &DBSyncProvider, + pool_hash: &str, +) -> Result { + Ok( + pool_update::table + .inner_join(pool_hash::table.on(pool_hash::id.eq(pool_update::hash_id))) + .inner_join(stake_address::table.on(stake_address::id.eq(pool_update::reward_addr_id))) + .filter(pool_hash::view.eq(pool_hash.to_string())) + .order(pool_update::active_epoch_no.desc()) + .select(stake_address::view) + .first::(&mut dbs.connect()?)? + ) +} + +/// The epoch (active epoch number) during which the pool +/// made its latest registration. +pub async fn pool_registration( + dbs: &DBSyncProvider, + pool_hash: &str, +) -> Result { + Ok( + pool_update::table + .left_join(pool_hash::table.on(pool_hash::id.eq(pool_update::hash_id))) + .filter(pool_hash::view.eq(pool_hash.to_string())) + .order(pool_update::active_epoch_no.desc()) + .select(pool_update::active_epoch_no) + .first::(&mut dbs.connect()?)? + ) +} + +/// The epoch in which the given pool retired. +pub async fn pool_retirement( + dbs: &DBSyncProvider, + pool_hash: &str, +) -> Result { + Ok( + pool_retire::table + .inner_join(pool_hash::table.on(pool_hash::id.eq(pool_retire::hash_id))) + .filter(pool_hash::view.eq(pool_hash)) + .select(pool_retire::retiring_epoch) + .first::(&mut dbs.connect()?)? + ) +} + +/// The url in which the given stake pool stores its metadata. +/// Just like Metadata Json stored on the chain, this includes: +/// name, ticker, homepage, description. But it also may include +/// additional metadata as chosen by the pool owner. +pub async fn pool_url( + dbs: &DBSyncProvider, + pool_hash: &str, +) -> Result { + Ok( + pool_metadata_ref::table + .inner_join(pool_hash::table.on(pool_hash::id.eq(pool_metadata_ref::pool_id))) + .filter(pool_hash::view.eq(pool_hash.to_string())) + .order(pool_metadata_ref::registered_tx_id.desc()) + .select(pool_metadata_ref::url) + .first::(&mut dbs.connect()?)? + ) +} + +/// The ticker (abbreviated name) of the given stakepool. +pub async fn pool_ticker( + dbs: &DBSyncProvider, + pool_hash: &str, +) -> Result { + Ok( + pool_offline_data::table + .inner_join(pool_hash::table.on(pool_hash::id.eq(pool_offline_data::pool_id))) + .filter(pool_hash::view.eq(pool_hash.to_string())) + .select(pool_offline_data::ticker_name) + .first::(&mut dbs.connect()?)? + ) +} + +/// The metadata, in JSON format, of the given stakepool. +pub async fn pool_metadata_json( + dbs: &DBSyncProvider, + pool_hash: &str, +) -> Result { + Ok( + pool_offline_data::table + .inner_join(pool_hash::table.on(pool_hash::id.eq(pool_offline_data::pool_id))) + .filter(pool_hash::view.eq(pool_hash)) + .select(pool_offline_data::json) + .first::(&mut dbs.connect()?)? + ) +} + +/// Name of the given stakepool. +pub async fn pool_name( + dbs: &DBSyncProvider, + pool_hash: &str, +) -> Result { + Ok( + pool_offline_data::table + .inner_join(pool_hash::table.on(pool_hash::id.eq(pool_offline_data::pool_id))) + .filter(pool_hash::view.eq(pool_hash)) + .select(pool_offline_data::json) + .first::(&mut dbs.connect()?)? + .as_object() + .unwrap() + .get("name") + .unwrap() + .as_str() + .unwrap() + .to_string() + ) +} + +/// The website (url) that officially represents the given stakepool. +pub async fn pool_homepage( + dbs: &DBSyncProvider, + pool_hash: &str, +) -> Result { + Ok( + pool_offline_data::table + .inner_join(pool_hash::table.on(pool_hash::id.eq(pool_offline_data::pool_id))) + .filter(pool_hash::view.eq(pool_hash)) + .select(pool_offline_data::json) + .first::(&mut dbs.connect()?)? + .as_object() + .unwrap() + .get("homepage") + .unwrap() + .as_str() + .unwrap() + .to_string() + ) +} + +/// Arbitrary message written by the given pool owner. +/// Usually describes the given pool. +pub async fn pool_description( + dbs: &DBSyncProvider, + pool_hash: &str, +) -> Result { + Ok( + pool_offline_data::table + .inner_join(pool_hash::table.on(pool_hash::id.eq(pool_offline_data::pool_id))) + .filter(pool_hash::view.eq(pool_hash)) + .select(pool_offline_data::json) + .first::(&mut dbs.connect()?)? + .as_object() + .unwrap() + .get("description") + .unwrap() + .as_str() + .unwrap() + .to_string() + ) +} + #[cfg(test)] mod tests { use crate::{dbsync::DataProviderDBSyncError, provider::CardanoDataProvider}; use bigdecimal::BigDecimal; use itertools::Itertools; + use serde_json::json; use std::str::FromStr; #[tokio::test] @@ -2170,4 +2467,208 @@ mod tests { assert_eq!(hex::encode(utxo_tokens[2].policy.clone()), "dfd18a815a25339777dcc80bce9c438ad632272d95f334a111711ac9"); assert_eq!(hex::encode(utxo_tokens[2].name.clone()), "7441726b"); } + + #[tokio::test] + async fn pool_vrf_key_hash() { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), + })); + let pool_hash = "pool1uh5xdjv70q5eyl5z644p23mvhd3dx0gwr8pjnlj9pwd3jgkvd0e"; + let _func_value = hex::encode(super::pool_vrf_key_hash(dp.provider(), pool_hash).await.unwrap()); + let _manual_value = "335399acf3228243efb0fec0e43f18d61a496d4fd740fd800f9b91b5fa7d0540"; + + // assert_eq!(_func_value, _manual_value); // The value change in the future. But it passed at the time of this writing. + } + + #[tokio::test] + async fn pool_blocks_minted() { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), + })); + let pool_hash = "pool1uh5xdjv70q5eyl5z644p23mvhd3dx0gwr8pjnlj9pwd3jgkvd0e"; + let _func_value = super::pool_blocks_minted(dp.provider(), pool_hash).await.unwrap(); + let _manual_value = 13; + + // assert_eq!(_func_value, _manual_value); // The value change in the future. But it passed at the time of this writing. + } + + #[tokio::test] + async fn pool_blocks_current_epoch() { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), + })); + let pool_hash = "pool14u22dyym8k2g2twvgct86njg3m9cc7j2fc74yamy6672s6up7a0"; + let _func_value = super::pool_blocks_current_epoch(dp.provider(), pool_hash).await.unwrap(); + let _manual_value = 25; + + // assert_eq!(_func_value, _manual_value); // The value change in the future. But it passed at the time of this writing. + } + + #[tokio::test] + async fn pool_live_delegators() { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), + })); + let pool_hash = "pool1rk2y9gx6vll8lawzdqlky5p2a3ypzsxg07arg8gmhkjj2905035"; + let _func_value = super::pool_live_delegators(dp.provider(), pool_hash).await.unwrap(); // TODO:: FixMe + let _manual_value = 104; + + // assert_eq!(_func_value, _manual_value); // TODO: make this unit test work + } + + #[tokio::test] + async fn pool_declared_pledge() { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), + })); + let pool_hash = "pool1vezalga3ge0mt0xf4txz66ctufk6nrmemhhpshwkhedk5jf0stw"; + let _func_value = super::pool_declared_pledge(dp.provider(), pool_hash).await.unwrap(); + let _manual_value = BigDecimal::from_str("125000000000").unwrap(); + + // assert_eq!(_func_value, _manual_value); // The value change in the future. But it passed at the time of this writing. + } + + #[tokio::test] + async fn pool_margin_cost() { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), + })); + let pool_hash = "pool1vezalga3ge0mt0xf4txz66ctufk6nrmemhhpshwkhedk5jf0stw"; + let _func_value = super::pool_margin_cost(dp.provider(), pool_hash).await.unwrap(); + let _manual_value = 0.075; + + // assert_eq!(_func_value, _manual_value); // The value change in the future. But it passed at the time of this writing. + } + + #[tokio::test] + async fn pool_fixed_cost() { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), + })); + let pool_hash = "pool1vezalga3ge0mt0xf4txz66ctufk6nrmemhhpshwkhedk5jf0stw"; + let _func_value = super::pool_fixed_cost(dp.provider(), pool_hash).await.unwrap(); + let _manual_value = BigDecimal::from_str("340000000").unwrap(); + + // assert_eq!(_func_value, _manual_value); // The value change in the future. But it passed at the time of this writing. + } + + #[tokio::test] + async fn pool_reward_address() { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), + })); + let pool_hash = "pool1vezalga3ge0mt0xf4txz66ctufk6nrmemhhpshwkhedk5jf0stw"; + let _func_value = super::pool_reward_address(dp.provider(), pool_hash).await.unwrap(); + let _manual_value = "stake_test1uz5ah77y8xvnxs6cyp979hg7fhxezjw39jfrpardqymnz7sg7ea8y"; + + // assert_eq!(_func_value, _manual_value); // The value change in the future. But it passed at the time of this writing. + } + + #[tokio::test] + async fn pool_owner() { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), + })); + let pool_hash = "pool1vezalga3ge0mt0xf4txz66ctufk6nrmemhhpshwkhedk5jf0stw"; + let _func_value = super::pool_owner(dp.provider(), pool_hash).await.unwrap(); + let _manual_value = "stake_test1uz5ah77y8xvnxs6cyp979hg7fhxezjw39jfrpardqymnz7sg7ea8y"; + + // assert_eq!(_func_value, _manual_value); // The value change in the future. But it passed at the time of this writing. + } + + #[tokio::test] + async fn pool_registration() { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), + })); + let pool_hash = "pool1vezalga3ge0mt0xf4txz66ctufk6nrmemhhpshwkhedk5jf0stw"; + let _func_value = super::pool_registration(dp.provider(), pool_hash).await.unwrap(); + let _manual_value = 175; + + // assert_eq!(_func_value, _manual_value); // The value change in the future. But it passed at the time of this writing. + } + + #[tokio::test] + async fn pool_retirement() { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), + })); + let pool_hash = "pool17hsjytkcntlh6py4gnmk4695cux28tpcxrggs9ln97mvvtplr2m"; + let func_value = super::pool_retirement(dp.provider(), pool_hash).await.unwrap(); + let manual_value = 26; + + assert_eq!(func_value, manual_value); // The value change in the future. But it passed at the time of this writing. + } + + #[tokio::test] + async fn pool_url() { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), + })); + let pool_hash = "pool17hsjytkcntlh6py4gnmk4695cux28tpcxrggs9ln97mvvtplr2m"; + let _func_value = super::pool_url(dp.provider(), pool_hash).await.unwrap(); + let _manual_value = "https://armadacardano.io/metadata.json"; + + // assert_eq!(_func_value, _manual_value); // The value change in the future. But it passed at the time of this writing. + } + + #[tokio::test] + async fn pool_ticker() { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), + })); + let pool_hash = "pool1l5u4zh84na80xr56d342d32rsdw62qycwaw97hy9wwsc6axdwla"; + let _func_value = super::pool_ticker(dp.provider(), pool_hash).await.unwrap(); + let _manual_value = "EUSKL"; + + // assert_eq!(_func_value, _manual_value); // The value change in the future. But it passed at the time of this writing. + } + + #[tokio::test] + async fn pool_metadata_json() { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), + })); + let pool_hash = "pool1l5u4zh84na80xr56d342d32rsdw62qycwaw97hy9wwsc6axdwla"; + let _func_value = super::pool_metadata_json(dp.provider(), pool_hash).await.unwrap(); + let _manual_value = json!({"name": "EUSKAL STAKE POOL TESTNET", "ticker": "EUSKL", "homepage": "https://euskalstakepool.win", "description": "EUSKAL STAKE POOL TESTNET"}); + + // assert_eq!(_func_value, _manual_value); // The value change in the future. But it passed at the time of this writing. + } + + #[tokio::test] + async fn pool_name() { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), + })); + let pool_hash = "pool1l5u4zh84na80xr56d342d32rsdw62qycwaw97hy9wwsc6axdwla"; + let _func_value = super::pool_name(dp.provider(), pool_hash).await.unwrap(); + let _manual_value = "EUSKAL STAKE POOL TESTNET"; + + // assert_eq!(_func_value, _manual_value); // The value change in the future. But it passed at the time of this writing. + } + + #[tokio::test] + async fn pool_homepage() { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), + })); + let pool_hash = "pool1l5u4zh84na80xr56d342d32rsdw62qycwaw97hy9wwsc6axdwla"; + let _func_value = super::pool_homepage(dp.provider(), pool_hash).await.unwrap(); + let _manual_value = "https://euskalstakepool.win"; + + // assert_eq!(_func_value, _manual_value); // The value change in the future. But it passed at the time of this writing. + } + + #[tokio::test] + async fn pool_description() { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), + })); + let pool_hash = "pool1l5u4zh84na80xr56d342d32rsdw62qycwaw97hy9wwsc6axdwla"; + let _func_value = super::pool_description(dp.provider(), pool_hash).await.unwrap(); + let _manual_value = "EUSKAL STAKE POOL TESTNET"; + + // assert_eq!(_func_value, _manual_value); // The value change in the future. But it passed at the time of this writing. + } } \ No newline at end of file diff --git a/src/dbsync/mod.rs b/src/dbsync/mod.rs index 2dc5a26..5b01496 100644 --- a/src/dbsync/mod.rs +++ b/src/dbsync/mod.rs @@ -9,6 +9,7 @@ mod schema; use diesel::pg::PgConnection; use diesel::prelude::*; use bigdecimal::BigDecimal; +use serde_json::Value; use crate::models::{CDPDatum, RewardView, TokenInfoView, CardanoNativeAssetView, StakeDelegationView, DelegationView, StakeRegistrationView, StakeDeregistrationView, HoldingWalletView, @@ -263,4 +264,116 @@ impl super::provider::CardanoDataProvider for DBSyncProvider { ) -> Result, DataProviderError> { Ok(api::retrieve_generated_rewards(self, stake_addr)?) } + + async fn pool_vrf_key_hash ( + &self, + pool_hash: &str, + ) -> Result, DataProviderError> { + Ok(api::pool_vrf_key_hash(self, pool_hash).await?) + } + + async fn pool_blocks_minted ( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_blocks_minted(self, pool_hash).await?) + } + + async fn pool_blocks_current_epoch( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_blocks_current_epoch(self, pool_hash).await?) + } + + async fn pool_declared_pledge( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_declared_pledge(self, pool_hash).await?) + } + + async fn pool_margin_cost( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_margin_cost(self, pool_hash).await?) + } + + async fn pool_fixed_cost( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_fixed_cost(self, pool_hash).await?) + } + + async fn pool_reward_address( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_reward_address(self, pool_hash).await?) + } + + async fn pool_owner( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_owner(self, pool_hash).await?) + } + + async fn pool_registration( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_registration(self, pool_hash).await?) + } + + async fn pool_retirement( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_retirement(self, pool_hash).await?) + } + + async fn pool_url( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_url(self, pool_hash).await?) + } + + async fn pool_ticker( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_ticker(self, pool_hash).await?) + } + + async fn pool_metadata_json( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_metadata_json(self, pool_hash).await?) + } + + async fn pool_name( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_name(self, pool_hash).await?) + } + + async fn pool_homepage( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_homepage(self, pool_hash).await?) + } + + async fn pool_description( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_description(self, pool_hash).await?) + } } diff --git a/src/dbsync/models.rs b/src/dbsync/models.rs index 46bc52a..ca433b9 100644 --- a/src/dbsync/models.rs +++ b/src/dbsync/models.rs @@ -590,7 +590,7 @@ pub struct PoolUpdate { pub cert_index: i32, pub vrf_key_hash: Vec, pub pledge: BigDecimal, - pub reward_addr: Vec, + pub reward_addr_id: i64, pub active_epoch_no: i64, pub meta_id: Option, pub margin: f64, diff --git a/src/dbsync/schema.rs b/src/dbsync/schema.rs index cc907ce..60af444 100644 --- a/src/dbsync/schema.rs +++ b/src/dbsync/schema.rs @@ -397,7 +397,7 @@ table! { cert_index -> Int4, vrf_key_hash -> Bytea, pledge -> Numeric, - reward_addr -> Bytea, + reward_addr_id -> Int8, active_epoch_no -> Int8, meta_id -> Nullable, margin -> Float8, diff --git a/src/koios/api.rs b/src/koios/api.rs index 1030df4..ba902d0 100644 --- a/src/koios/api.rs +++ b/src/koios/api.rs @@ -5,6 +5,7 @@ use crate::models::{ StakeDeregistrationView, StakeRegistrationView, TokenInfoView, RewardView, }; use bigdecimal::BigDecimal; +use serde_json::{Value, json}; /// get all tokens of an utxo pub fn get_utxo_tokens( @@ -199,4 +200,116 @@ pub fn retrieve_generated_rewards ( stake_addr: &str, ) -> Result, DataProviderKoiosError> { Ok(vec![]) +} + +pub fn pool_vrf_key_hash( + bfp: &KoiosProvider, + pool_hash: &str, +) -> Result, DataProviderKoiosError> { + Ok(vec![]) +} + +pub fn pool_blocks_minted( + bfp: &KoiosProvider, + pool_hash: &str, +) -> Result { + Ok(0) +} + +pub fn pool_blocks_current_epoch( + bfp: &KoiosProvider, + pool_hash: &str, +) -> Result { + Ok(0) +} + +pub fn pool_declared_pledge( + bfp: &KoiosProvider, + pool_hash: &str, +) -> Result { + Ok(BigDecimal::from(0)) +} + +pub fn pool_margin_cost( + bfp: &KoiosProvider, + pool_hash: &str, +) -> Result { + Ok(0.0) +} + +pub fn pool_fixed_cost( + bfp: &KoiosProvider, + pool_hash: &str, +) -> Result { + Ok(BigDecimal::from(0)) +} + +pub fn pool_reward_address( + bfp: &KoiosProvider, + pool_hash: &str, +) -> Result { + Ok("".to_string()) +} + +pub fn pool_owner( + bfp: &KoiosProvider, + pool_hash: &str, +) -> Result { + Ok("".to_string()) +} + +pub fn pool_registration( + bfp: &KoiosProvider, + pool_hash: &str, +) -> Result { + Ok(0) +} + +pub fn pool_retirement( + bfp: &KoiosProvider, + pool_hash: &str, +) -> Result { + Ok(0) +} + +pub fn pool_url( + bfp: &KoiosProvider, + pool_hash: &str, +) -> Result { + Ok("".to_string()) +} + +pub fn pool_ticker( + bfp: &KoiosProvider, + pool_hash: &str, +) -> Result { + Ok("".to_string()) +} + +pub fn pool_metadata_json( + bfp: &KoiosProvider, + pool_hash: &str, +) -> Result { + Ok(json!({})) +} + +pub fn pool_name( + bfp: &KoiosProvider, + pool_hash: &str, +) -> Result { + Ok("".to_string()) +} + +pub fn pool_homepage( + bfp: &KoiosProvider, + pool_hash: &str, +) -> Result { + Ok("".to_string()) +} + +pub fn pool_description( + bfp: &KoiosProvider, + pool_hash: &str, +) -> Result { + Ok("".to_string()) } \ No newline at end of file diff --git a/src/koios/mod.rs b/src/koios/mod.rs index 568be1e..1c4fec6 100644 --- a/src/koios/mod.rs +++ b/src/koios/mod.rs @@ -9,6 +9,7 @@ pub mod api; pub mod error; pub mod models; use bigdecimal::BigDecimal; +use serde_json::Value; pub struct Config { pub url: String, @@ -253,4 +254,116 @@ impl super::provider::CardanoDataProvider for KoiosProvider { ) -> Result, DataProviderError> { Ok(api::retrieve_generated_rewards(self, stake_addr)?) } + + async fn pool_vrf_key_hash( + &self, + pool_hash: &str, + ) -> Result, DataProviderError> { + Ok(api::pool_vrf_key_hash(self, pool_hash)?) + } + + async fn pool_blocks_minted( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_blocks_minted(self, pool_hash)?) + } + + async fn pool_blocks_current_epoch( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_blocks_current_epoch(self, pool_hash)?) + } + + async fn pool_declared_pledge( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_declared_pledge(self, pool_hash)?) + } + + async fn pool_margin_cost( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_margin_cost(self, pool_hash)?) + } + + async fn pool_fixed_cost( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_fixed_cost(self, pool_hash)?) + } + + async fn pool_reward_address( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_reward_address(self, pool_hash)?) + } + + async fn pool_owner( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_owner(self, pool_hash)?) + } + + async fn pool_registration( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_registration(self, pool_hash)?) + } + + async fn pool_retirement( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_retirement(self, pool_hash)?) + } + + async fn pool_url( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_url(self, pool_hash)?) + } + + async fn pool_ticker( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_ticker(self, pool_hash)?) + } + + async fn pool_metadata_json( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_metadata_json(self, pool_hash)?) + } + + async fn pool_name( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_name(self, pool_hash)?) + } + + async fn pool_homepage( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_homepage(self, pool_hash)?) + } + + async fn pool_description( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_description(self, pool_hash)?) + } } diff --git a/src/provider/mod.rs b/src/provider/mod.rs index 3111dc6..d1f672d 100644 --- a/src/provider/mod.rs +++ b/src/provider/mod.rs @@ -12,6 +12,7 @@ use cardano_serialization_lib::address::Address; use dcslc::TransactionUnspentOutputs; use error::DataProviderError; use bigdecimal::BigDecimal; +use serde_json::Value; #[async_trait] pub trait CardanoDataProvider { @@ -134,6 +135,85 @@ pub trait CardanoDataProvider { stake_addr: &str, ) -> Result, DataProviderError>; + async fn pool_vrf_key_hash( + &self, + pool_hash: &str, + ) -> Result, DataProviderError>; + + async fn pool_blocks_minted( + &self, + pool_hash: &str, + ) -> Result; + + async fn pool_blocks_current_epoch( + &self, + pool_hash: &str, + ) -> Result; + + async fn pool_declared_pledge( + &self, + pool_hash: &str, + ) -> Result; + + async fn pool_margin_cost( + &self, + pool_hash: &str, + ) -> Result; + + async fn pool_fixed_cost( + &self, + pool_hash: &str, + ) -> Result; + + async fn pool_reward_address( + &self, + pool_hash: &str, + ) -> Result; + + async fn pool_owner( + &self, + pool_hash: &str, + ) -> Result; + + async fn pool_registration( + &self, + pool_hash: &str, + ) -> Result; + + async fn pool_retirement( + &self, + pool_hash: &str, + ) -> Result; + + async fn pool_url( + &self, + pool_hash: &str, + ) -> Result; + + async fn pool_ticker( + &self, + pool_hash: &str, + ) -> Result; + + async fn pool_metadata_json( + &self, + pool_hash: &str, + ) -> Result; + + async fn pool_name( + &self, + pool_hash: &str, + ) -> Result; + + async fn pool_homepage( + &self, + pool_hash: &str, + ) -> Result; + + async fn pool_description( + &self, + pool_hash: &str, + ) -> Result; } pub struct DataProvider { @@ -339,4 +419,116 @@ impl CardanoData ) -> Result, DataProviderError> { dbg!(self.provider().retrieve_generated_rewards(stake_addr).await) } + + async fn pool_vrf_key_hash ( + &self, + pool_hash: &str, + ) -> Result, DataProviderError> { + self.provider().pool_vrf_key_hash(pool_hash).await + } + + async fn pool_blocks_minted ( + &self, + pool_hash: &str, + ) -> Result { + self.provider().pool_blocks_minted(pool_hash).await + } + + async fn pool_blocks_current_epoch ( + &self, + pool_hash: &str, + ) -> Result { + self.provider().pool_blocks_current_epoch(pool_hash).await + } + + async fn pool_declared_pledge ( + &self, + pool_hash: &str, + ) -> Result { + self.provider().pool_declared_pledge(pool_hash).await + } + + async fn pool_margin_cost( + &self, + pool_hash: &str, + ) -> Result { + self.provider().pool_margin_cost(pool_hash).await + } + + async fn pool_fixed_cost( + &self, + pool_hash: &str, + ) -> Result { + self.provider().pool_fixed_cost(pool_hash).await + } + + async fn pool_reward_address( + &self, + pool_hash: &str, + ) -> Result { + self.provider().pool_reward_address(pool_hash).await + } + + async fn pool_owner( + &self, + pool_hash: &str, + ) -> Result { + self.provider().pool_owner(pool_hash).await + } + + async fn pool_registration( + &self, + pool_hash: &str, + ) -> Result { + self.provider().pool_registration(pool_hash).await + } + + async fn pool_retirement( + &self, + pool_hash: &str, + ) -> Result { + self.provider().pool_retirement(pool_hash).await + } + + async fn pool_url( + &self, + pool_hash: &str, + ) -> Result { + self.provider().pool_url(pool_hash).await + } + + async fn pool_ticker( + &self, + pool_hash: &str, + ) -> Result { + self.provider().pool_ticker(pool_hash).await + } + + async fn pool_metadata_json( + &self, + pool_hash: &str, + ) -> Result { + self.provider().pool_metadata_json(pool_hash).await + } + + async fn pool_name( + &self, + pool_hash: &str, + ) -> Result { + self.provider().pool_name(pool_hash).await + } + + async fn pool_homepage( + &self, + pool_hash: &str, + ) -> Result { + self.provider().pool_homepage(pool_hash).await + } + + async fn pool_description( + &self, + pool_hash: &str, + ) -> Result { + self.provider().pool_description(pool_hash).await + } } diff --git a/src/server/handler/handler_rest/info.rs b/src/server/handler/handler_rest/info.rs index 733ec7f..21f3a18 100644 --- a/src/server/handler/handler_rest/info.rs +++ b/src/server/handler/handler_rest/info.rs @@ -532,6 +532,360 @@ pub async fn retrieve_generated_rewards( Ok(rweb::Json::from(json!(generated_rewards))) } +#[get("/pool/vrf_key_hash/{pool_hash}")] +#[openapi( + id = "api.info.pool.vrf_key_hash", + tags("Pool"), + summary = "VRF key hash generated by the pool's VRF private key" +)] +pub async fn pool_vrf_key_hash( + pool_hash: String, + #[filter = "with_auth"] _user_id: String, +) -> Result, Rejection> { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: std::env::var("DBSYNC_URL").unwrap(), + })); + + let pool_vrf_key_hash = dp + .pool_vrf_key_hash(&pool_hash) + .await + .map_err(|_| RESTError::Custom("Couldn't find pools VRF key hash".to_string()))?; + + Ok(rweb::Json::from(json!(pool_vrf_key_hash))) +} + +#[get("/pool/blocks_minted/{pool_hash}")] +#[openapi( + id = "api.info.pool.blocks_minted", + tags("Pool"), + summary = "Total number of blocks minted by the given pool" +)] +pub async fn pool_blocks_minted( + pool_hash: String, + #[filter = "with_auth"] _user_id: String, +) -> Result, Rejection> { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: std::env::var("DBSYNC_URL").unwrap(), + })); + + let pool_blocks_minted = dp + .pool_blocks_minted(&pool_hash) + .await + .map_err(|_| RESTError::Custom("Couldn't find the total number of blocks minted by the given pool".to_string()))?; + + Ok(rweb::Json::from(json!(pool_blocks_minted))) +} + +#[get("/pool/blocks_current_epoch/{pool_hash}")] +#[openapi( + id = "api.info.pool.blocks_current_epoch", + tags("Pool"), + summary = "Quantity of blocks minted by the given pool in current epoch" +)] +pub async fn pool_blocks_current_epoch( + pool_hash: String, + #[filter = "with_auth"] _user_id: String, +) -> Result, Rejection> { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: std::env::var("DBSYNC_URL").unwrap(), + })); + + let pool_blocks_current_epoch = dp + .pool_blocks_current_epoch(&pool_hash) + .await + .map_err(|_| RESTError::Custom("Couldn't find the quantity of blocks minted by the given pool in current epoch".to_string()))?; + + Ok(rweb::Json::from(json!(pool_blocks_current_epoch))) +} + +// #[get("pool/live_delegators/{pool_hash}")] // TODO: FixMe (start with dbsync/api.rs) + +#[get("/pool/declared_pledge/{pool_hash}")] +#[openapi( + id = "api.info.pool.declared_pledge", + tags("Pool"), + summary = "The amount of Ada that the given stake pool has pledged to stake into their own pool" +)] +pub async fn pool_declared_pledge( + pool_hash: String, + #[filter = "with_auth"] _user_id: String, +) -> Result, Rejection> { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: std::env::var("DBSYNC_URL").unwrap(), + })); + + let pool_declared_pledge = dp + .pool_declared_pledge(&pool_hash) + .await + .map_err(|_| RESTError::Custom("Couldn't find the amount of Ada pledged by the given pool".to_string()))?; + + Ok(rweb::Json::from(json!(pool_declared_pledge))) +} + +#[get("/pool/margin_cost/{pool_hash}")] +#[openapi( + id = "api.info.pool.margin_cost", + tags("Pool"), + summary = "The percentage of delegator's stake rewards that pool owner receives as compensation for enabling delegators to delegate" +)] +pub async fn pool_margin_cost( + pool_hash: String, + #[filter = "with_auth"] _user_id: String, +) -> Result, Rejection> { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: std::env::var("DBSYNC_URL").unwrap(), + })); + + let pool_margin_cost = dp + .pool_margin_cost(&pool_hash) + .await + .map_err(|_| RESTError::Custom("Couldn't find the margin cost of the given pool".to_string()))?; + + Ok(rweb::Json::from(json!(pool_margin_cost))) +} + +#[get("/pool/fixed_cost/{pool_hash}")] +#[openapi( + id = "api.info.pool.fixed_cost", + tags("Pool"), + summary = "The fixed amount of Ada that the given stake pool receives every epoch from each delegator" +)] +pub async fn pool_fixed_cost( + pool_hash: String, + #[filter = "with_auth"] _user_id: String, +) -> Result, Rejection> { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: std::env::var("DBSYNC_URL").unwrap(), + })); + + let pool_fixed_cost = dp + .pool_fixed_cost(&pool_hash) + .await + .map_err(|_| RESTError::Custom("Couldn't find the fixed cost of the given pool".to_string()))?; + + Ok(rweb::Json::from(json!(pool_fixed_cost))) +} + +#[get("/pool/reward_address/{pool_hash}")] +#[openapi( + id = "api.info.pool.reward_address", + tags("Pool"), + summary = "The stake address to which the delegators pay the fixed cost and margin cost." +)] +pub async fn pool_reward_address( + pool_hash: String, + #[filter = "with_auth"] _user_id: String, +) -> Result, Rejection> { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: std::env::var("DBSYNC_URL").unwrap(), + })); + + let pool_reward_address = dp + .pool_reward_address(&pool_hash) + .await + .map_err(|_| RESTError::Custom("Couldn't find the reward address of the given pool".to_string()))?; + + Ok(rweb::Json::from(json!(pool_reward_address))) +} + +#[get("/pool/owner/{pool_hash}")] +#[openapi( + id = "api.info.pool.owner", + tags("Pool"), + summary = "The stake address that represents the owner of the given stake pool" +)] +pub async fn pool_owner( + pool_hash: String, + #[filter = "with_auth"] _user_id: String, +) -> Result, Rejection> { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: std::env::var("DBSYNC_URL").unwrap(), + })); + + let pool_owner = dp + .pool_owner(&pool_hash) + .await + .map_err(|_| RESTError::Custom("Couldn't find the owner of the given pool".to_string()))?; + + Ok(rweb::Json::from(json!(pool_owner))) +} + +#[get("/pool/registration/{pool_hash}")] +#[openapi( + id = "api.info.pool.registration", + tags("Pool"), + summary = "The epoch in which the given stake pool made its latest registration." +)] +pub async fn pool_registration( + pool_hash: String, + #[filter = "with_auth"] _user_id: String, +) -> Result, Rejection> { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: std::env::var("DBSYNC_URL").unwrap(), + })); + + let pool_registration = dp + .pool_registration(&pool_hash) + .await + .map_err(|_| RESTError::Custom("Couldn't find the epoch in which the given pool made its latest registration".to_string()))?; + + Ok(rweb::Json::from(json!(pool_registration))) +} + +#[get("/pool/retirement/{pool_hash}")] +#[openapi( + id = "api.info.pool.retirement", + tags("Pool"), + summary = "The epoch in which the given pool retired." +)] +pub async fn pool_retirement( + pool_hash: String, + #[filter = "with_auth"] _user_id: String, +) -> Result, Rejection> { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: std::env::var("DBSYNC_URL").unwrap(), + })); + + let pool_retirement = dp + .pool_retirement(&pool_hash) + .await + .map_err(|_| RESTError::Custom("Couldn't find the epoch in which the given pool retired".to_string()))?; + + Ok(rweb::Json::from(json!(pool_retirement))) +} + +#[get("/pool/url/{pool_hash}")] +#[openapi( + id = "api.info.pool.url", + tags("Pool"), + summary = "The url in which the given pool stores its metadata." +)] +pub async fn pool_url( + pool_hash: String, + #[filter = "with_auth"] _user_id: String, +) -> Result, Rejection> { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: std::env::var("DBSYNC_URL").unwrap(), + })); + + let pool_url = dp + .pool_url(&pool_hash) + .await + .map_err(|_| RESTError::Custom("Couldn't find the url in which the given pool stores its metadata".to_string()))?; + + Ok(rweb::Json::from(json!(pool_url))) +} + +#[get("/pool/ticker/{pool_hash}")] +#[openapi( + id = "api.info.pool.ticker", + tags("Pool"), + summary = "The ticker (abbreviated name) of the given stakepool." +)] +pub async fn pool_ticker( + pool_hash: String, + #[filter = "with_auth"] _user_id: String, +) -> Result, Rejection> { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: std::env::var("DBSYNC_URL").unwrap(), + })); + + let pool_ticker = dp + .pool_ticker(&pool_hash) + .await + .map_err(|_| RESTError::Custom("Couldn't find the ticker of the given stake pool".to_string()))?; + + Ok(rweb::Json::from(json!(pool_ticker))) +} + +#[get("/pool/metadata_json/{pool_hash}")] +#[openapi( + id = "api.info.pool.metadata_json", + tags("Pool"), + summary = "Metadata, of the given stake pool, presented in JSON format" +)] +pub async fn pool_metadata_json( + pool_hash: String, + #[filter = "with_auth"] _user_id: String, +) -> Result, Rejection> { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: std::env::var("DBSYNC_URL").unwrap(), + })); + + let pool_metadata_json = dp + .pool_metadata_json(&pool_hash) + .await + .map_err(|_| RESTError::Custom("Couldn't find the metadata JSON of the given stake pool".to_string()))?; + + Ok(rweb::Json::from(pool_metadata_json)) +} + +#[get("/pool/name/{pool_hash}")] +#[openapi( + id = "api.info.pool.name", + tags("Pool"), + summary = "Name of the given stake pool" +)] +pub async fn pool_name( + pool_hash: String, + #[filter = "with_auth"] _user_id: String, +) -> Result, Rejection> { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: std::env::var("DBSYNC_URL").unwrap(), + })); + + let pool_name = dp + .pool_name(&pool_hash) + .await + .map_err(|_| RESTError::Custom("Couldn't find the name of the given stake pool".to_string()))?; + + Ok(rweb::Json::from(json!(pool_name))) +} + +#[get("/pool/homepage/{pool_hash}")] +#[openapi( + id = "api.info.pool.homepage", + tags("Pool"), + summary = "Homepage of the given stake pool" +)] +pub async fn pool_homepage( + pool_hash: String, + #[filter = "with_auth"] _user_id: String, +) -> Result, Rejection> { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: std::env::var("DBSYNC_URL").unwrap(), + })); + + let pool_homepage = dp + .pool_homepage(&pool_hash) + .await + .map_err(|_| RESTError::Custom("Couldn't find the homepage of the given stake pool".to_string()))?; + + Ok(rweb::Json::from(json!(pool_homepage))) +} + +#[get("/pool/description/{pool_hash}")] +#[openapi( + id = "api.info.pool.description", + tags("Pool"), + summary = "Description of the given stake pool" +)] +pub async fn pool_description( + pool_hash: String, + #[filter = "with_auth"] _user_id: String, +) -> Result, Rejection> { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: std::env::var("DBSYNC_URL").unwrap(), + })); + + let pool_description = dp + .pool_description(&pool_hash) + .await + .map_err(|_| RESTError::Custom("Couldn't find the description of the given stake pool".to_string()))?; + + Ok(rweb::Json::from(json!(pool_description))) +} + #[cfg(test)] mod tests { diff --git a/src/server/handler/handler_rest/mod.rs b/src/server/handler/handler_rest/mod.rs index 4eec0d2..f427310 100644 --- a/src/server/handler/handler_rest/mod.rs +++ b/src/server/handler/handler_rest/mod.rs @@ -4,7 +4,10 @@ pub(crate) mod info; use info::{ address_exists, handle_asset_for_stake_address, handle_get_asset_for_addresses, is_nft, mint_metadata, retrieve_active_pools, token_supply, tx_history, tx_history_discover, - utxos_per_addr, retrieve_staked_amount, retrieve_generated_rewards, + utxos_per_addr, retrieve_staked_amount, retrieve_generated_rewards, pool_vrf_key_hash, + pool_blocks_minted, pool_blocks_current_epoch, pool_declared_pledge, pool_margin_cost, + pool_fixed_cost, pool_reward_address, pool_owner, pool_registration, pool_retirement, + pool_url, pool_ticker, pool_metadata_json, pool_name, pool_homepage, pool_description, }; use rweb::*; @@ -24,6 +27,22 @@ use rweb::*; is_nft, retrieve_staked_amount, retrieve_generated_rewards, + pool_vrf_key_hash, + pool_blocks_minted, + pool_blocks_current_epoch, + pool_declared_pledge, + pool_margin_cost, + pool_fixed_cost, + pool_reward_address, + pool_owner, + pool_registration, + pool_retirement, + pool_url, + pool_ticker, + pool_metadata_json, + pool_name, + pool_homepage, + pool_description, ) )] #[openapi(id = "api.info", description = "Information Requests")] From 9b2bf1f43705c4734405b79ff2449f64acb79d08 Mon Sep 17 00:00:00 2001 From: Amir Abdin Date: Sun, 24 Sep 2023 03:51:20 +0200 Subject: [PATCH 03/12] apply feedback --- src/blockfrost/api.rs | 32 ++++++++++++++++---------------- src/carb/api.rs | 32 ++++++++++++++++---------------- src/koios/api.rs | 32 ++++++++++++++++---------------- 3 files changed, 48 insertions(+), 48 deletions(-) diff --git a/src/blockfrost/api.rs b/src/blockfrost/api.rs index e4c64e2..78690d2 100644 --- a/src/blockfrost/api.rs +++ b/src/blockfrost/api.rs @@ -263,110 +263,110 @@ pub fn pool_vrf_key_hash ( bfp: &BlockfrostProvider, pool_hash: &str, ) -> Result, DataProviderError> { - Ok(vec![]) + todo!() } pub fn pool_blocks_minted ( bfp: &BlockfrostProvider, pool_hash: &str, ) -> Result { - Ok(0) + todo!() } pub fn pool_blocks_current_epoch( bfp: &BlockfrostProvider, pool_hash: &str, ) -> Result { - Ok(0) + todo!() } pub fn pool_declared_pledge( bfp: &BlockfrostProvider, pool_hash: &str, ) -> Result { - Ok(BigDecimal::from(0)) + todo!() } pub fn pool_margin_cost( bfp: &BlockfrostProvider, pool_hash: &str, ) -> Result { - Ok(0.0) + todo!() } pub fn pool_fixed_cost( bfp: &BlockfrostProvider, pool_hash: &str, ) -> Result { - Ok(BigDecimal::from(0)) + todo!() } pub fn pool_reward_address( bfp: &BlockfrostProvider, pool_hash: &str, ) -> Result { - Ok("".to_string()) + todo!() } pub fn pool_owner( bfp: &BlockfrostProvider, pool_hash: &str, ) -> Result { - Ok("".to_string()) + todo!() } pub fn pool_registration( bfp: &BlockfrostProvider, pool_hash: &str, ) -> Result { - Ok(0) + todo!() } pub fn pool_retirement( bfp: &BlockfrostProvider, pool_hash: &str, ) -> Result { - Ok(0) + todo!() } pub fn pool_url( bfp: &BlockfrostProvider, pool_hash: &str, ) -> Result { - Ok("".to_string()) + todo!() } pub fn pool_ticker( bfp: &BlockfrostProvider, pool_hash: &str, ) -> Result { - Ok("".to_string()) + todo!() } pub fn pool_metadata_json( bfp: &BlockfrostProvider, pool_hash: &str, ) -> Result { - Ok(json!({})) + todo!() } pub fn pool_name( bfp: &BlockfrostProvider, pool_hash: &str, ) -> Result { - Ok("".to_string()) + todo!() } pub fn pool_homepage( bfp: &BlockfrostProvider, pool_hash: &str, ) -> Result { - Ok("".to_string()) + todo!() } pub fn pool_description( bfp: &BlockfrostProvider, pool_hash: &str, ) -> Result { - Ok("".to_string()) + todo!() } \ No newline at end of file diff --git a/src/carb/api.rs b/src/carb/api.rs index 0da4e6a..6cabc61 100644 --- a/src/carb/api.rs +++ b/src/carb/api.rs @@ -204,110 +204,110 @@ pub fn pool_vrf_key_hash ( bfp: &CarbProvider, pool_hash: &str, ) -> Result, DataProviderError> { - Ok(vec![]) + todo!() } pub fn pool_blocks_minted ( bfp: &CarbProvider, pool_hash: &str, ) -> Result { - Ok(0) + todo!() } pub fn pool_blocks_current_epoch( bfp: &CarbProvider, pool_hash: &str, ) -> Result { - Ok(0) + todo!() } pub fn pool_declared_pledge( bfp: &CarbProvider, pool_hash: &str, ) -> Result { - Ok(BigDecimal::from(0)) + todo!() } pub fn pool_margin_cost ( bfp: &CarbProvider, pool_hash: &str, ) -> Result { - Ok(0.0) + todo!() } pub fn pool_fixed_cost( bfp: &CarbProvider, pool_hash: &str, ) -> Result { - Ok(BigDecimal::from(0)) + todo!() } pub fn pool_reward_address( bfp: &CarbProvider, pool_hash: &str, ) -> Result { - Ok("".to_string()) + todo!() } pub fn pool_owner( bfp: &CarbProvider, pool_hash: &str, ) -> Result { - Ok("".to_string()) + todo!() } pub fn pool_registration( bfp: &CarbProvider, pool_hash: &str, ) -> Result { - Ok(0) + todo!() } pub fn pool_retirement( bfp: &CarbProvider, pool_hash: &str, ) -> Result { - Ok(0) + todo!() } pub fn pool_url( bfp: &CarbProvider, pool_hash: &str, ) -> Result { - Ok("".to_string()) + todo!() } pub fn pool_ticker( bfp: &CarbProvider, pool_hash: &str, ) -> Result { - Ok("".to_string()) + todo!() } pub fn pool_metadata_json( bfp: &CarbProvider, pool_hash: &str, ) -> Result { - Ok(json!({})) + todo!() } pub fn pool_name( bfp: &CarbProvider, pool_hash: &str, ) -> Result { - Ok("".to_string()) + todo!() } pub fn pool_homepage( bfp: &CarbProvider, pool_hash: &str, ) -> Result { - Ok("".to_string()) + todo!() } pub fn pool_description( bfp: &CarbProvider, pool_hash: &str, ) -> Result { - Ok("".to_string()) + todo!() } \ No newline at end of file diff --git a/src/koios/api.rs b/src/koios/api.rs index ba902d0..b8055a9 100644 --- a/src/koios/api.rs +++ b/src/koios/api.rs @@ -206,110 +206,110 @@ pub fn pool_vrf_key_hash( bfp: &KoiosProvider, pool_hash: &str, ) -> Result, DataProviderKoiosError> { - Ok(vec![]) + todo!() } pub fn pool_blocks_minted( bfp: &KoiosProvider, pool_hash: &str, ) -> Result { - Ok(0) + todo!() } pub fn pool_blocks_current_epoch( bfp: &KoiosProvider, pool_hash: &str, ) -> Result { - Ok(0) + todo!() } pub fn pool_declared_pledge( bfp: &KoiosProvider, pool_hash: &str, ) -> Result { - Ok(BigDecimal::from(0)) + todo!() } pub fn pool_margin_cost( bfp: &KoiosProvider, pool_hash: &str, ) -> Result { - Ok(0.0) + todo!() } pub fn pool_fixed_cost( bfp: &KoiosProvider, pool_hash: &str, ) -> Result { - Ok(BigDecimal::from(0)) + todo!() } pub fn pool_reward_address( bfp: &KoiosProvider, pool_hash: &str, ) -> Result { - Ok("".to_string()) + todo!() } pub fn pool_owner( bfp: &KoiosProvider, pool_hash: &str, ) -> Result { - Ok("".to_string()) + todo!() } pub fn pool_registration( bfp: &KoiosProvider, pool_hash: &str, ) -> Result { - Ok(0) + todo!() } pub fn pool_retirement( bfp: &KoiosProvider, pool_hash: &str, ) -> Result { - Ok(0) + todo!() } pub fn pool_url( bfp: &KoiosProvider, pool_hash: &str, ) -> Result { - Ok("".to_string()) + todo!() } pub fn pool_ticker( bfp: &KoiosProvider, pool_hash: &str, ) -> Result { - Ok("".to_string()) + todo!() } pub fn pool_metadata_json( bfp: &KoiosProvider, pool_hash: &str, ) -> Result { - Ok(json!({})) + todo!() } pub fn pool_name( bfp: &KoiosProvider, pool_hash: &str, ) -> Result { - Ok("".to_string()) + todo!() } pub fn pool_homepage( bfp: &KoiosProvider, pool_hash: &str, ) -> Result { - Ok("".to_string()) + todo!() } pub fn pool_description( bfp: &KoiosProvider, pool_hash: &str, ) -> Result { - Ok("".to_string()) + todo!() } \ No newline at end of file From 0712d058706208045a760148e5ff53f7c1b205b4 Mon Sep 17 00:00:00 2001 From: Amir Abdin Date: Sun, 24 Sep 2023 04:59:28 +0200 Subject: [PATCH 04/12] Apply feedback --- src/{provider/mod.rs => provider.rs} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename src/{provider/mod.rs => provider.rs} (100%) diff --git a/src/provider/mod.rs b/src/provider.rs similarity index 100% rename from src/provider/mod.rs rename to src/provider.rs From 42d930ca4c6b644c176ddfe487845d46f6c7ed73 Mon Sep 17 00:00:00 2001 From: Amir Abdin Date: Mon, 9 Oct 2023 15:46:46 +0200 Subject: [PATCH 05/12] Refactor --- src/{blockfrost/mod.rs => blockfrost.rs} | 4 +- src/blockfrost/api.rs | 37 ++++------ src/{carb/mod.rs => carb.rs} | 4 +- src/carb/api.rs | 45 +++++------- src/{dbsync/mod.rs => dbsync.rs} | 4 +- src/dbsync/api.rs | 2 +- src/grpc/mod.rs | 10 +-- src/{koios/mod.rs => koios.rs} | 4 +- src/koios/api.rs | 51 +++++--------- src/proto/aya_cardano.proto | 10 +-- src/proto/aya_cardano.rs | 90 ++++++++++++------------ src/provider.rs | 6 +- 12 files changed, 116 insertions(+), 151 deletions(-) rename src/{blockfrost/mod.rs => blockfrost.rs} (98%) rename src/{carb/mod.rs => carb.rs} (98%) rename src/{dbsync/mod.rs => dbsync.rs} (98%) rename src/{koios/mod.rs => koios.rs} (98%) diff --git a/src/blockfrost/mod.rs b/src/blockfrost.rs similarity index 98% rename from src/blockfrost/mod.rs rename to src/blockfrost.rs index ed470a8..673430a 100644 --- a/src/blockfrost/mod.rs +++ b/src/blockfrost.rs @@ -141,13 +141,13 @@ impl super::provider::CardanoDataProvider for BlockfrostProvider { Ok(api::pool_delegations(self, pool, epoch)?) } - async fn deligations_per_pool_epoch_intervall( + async fn delegations_per_pool_epoch_intervall( &self, pool: &str, start_epoch: i64, end_epoch: i64, ) -> Result, DataProviderError> { - Ok(api::deligations_per_pool_for_epochs( + Ok(api::delegations_per_pool_for_epochs( self, pool, start_epoch, diff --git a/src/blockfrost/api.rs b/src/blockfrost/api.rs index 78690d2..b25688c 100644 --- a/src/blockfrost/api.rs +++ b/src/blockfrost/api.rs @@ -24,7 +24,7 @@ pub fn select_addr_of_first_transaction( bfp: &BlockfrostProvider, stake_address_in: &str, ) -> Result { - Ok("".to_owned()) + todo!() } /// get all utxos of an address @@ -33,9 +33,7 @@ pub fn utxo_by_dataumhash( addr: &str, datumhash: &Vec, ) -> Result { - Err(DataProviderBlockfrostError::Custom( - "not implemented".to_string(), - )) + todo!() } /// returns Utxo of a certain datumhash on an address @@ -44,9 +42,7 @@ pub fn utxo_by_txid( txhash: &Vec, index: i16, ) -> Result { - Err(DataProviderBlockfrostError::Custom( - "not implemented".to_string(), - )) + todo!() } /// get all utxos of an address @@ -137,7 +133,7 @@ pub fn pool_delegations( todo!(); } -pub fn deligations_per_pool_for_epochs( +pub fn delegations_per_pool_for_epochs( bfp: &BlockfrostProvider, pool: &str, start_epoch: i64, @@ -151,7 +147,7 @@ pub fn pool_total_stake( pool: &str, epoch: i32, ) -> Result { - Ok(0) + todo!() } pub async fn current_epoch(bfp: &BlockfrostProvider) -> Result { @@ -164,7 +160,7 @@ pub fn fingerprint( policy: &str, tokenname: &str, ) -> Result { - Ok("".to_owned()) + todo!() } pub fn token_info( @@ -193,7 +189,7 @@ pub fn check_stakeaddr_registered( bfp: &BlockfrostProvider, stake_addr_in: &str, ) -> Result { - Ok(false) + todo!() } pub fn lookup_token_holders( @@ -215,23 +211,14 @@ pub fn mint_metadata( bfp: &BlockfrostProvider, fingerprint_in: &str, ) -> Result { - Ok(TokenInfoView { - fingerprint: "".to_owned(), - policy: hex::encode(""), - tokenname: "".to_string(), - meta_key: None, - json: None, - txhash: None, - quantity: None, - mint_slot: None, - }) + todo!() } pub fn pool_valid( bfp: &BlockfrostProvider, pool_id: &str, ) -> Result { - Ok(true) + todo!() } pub fn txhash_spent( @@ -240,7 +227,7 @@ pub fn txhash_spent( ) -> Result { let txh_b = hex::decode(txhash)?; - Ok(false) + todo!() } pub fn retrieve_staked_amount ( @@ -248,14 +235,14 @@ pub fn retrieve_staked_amount ( epoch: i32, stake_addr: &str, ) -> Result { - Ok(BigDecimal::from(0)) + todo!() } pub fn retrieve_generated_rewards ( bfp: &BlockfrostProvider, stake_addr: &str, ) -> Result, DataProviderError> { - Ok(vec![]) + todo!() } diff --git a/src/carb/mod.rs b/src/carb.rs similarity index 98% rename from src/carb/mod.rs rename to src/carb.rs index 0532044..45edab8 100644 --- a/src/carb/mod.rs +++ b/src/carb.rs @@ -129,13 +129,13 @@ impl super::provider::CardanoDataProvider for CarbProvider { Ok(api::stakers_on_pool(self, pool, epoch)?) } - async fn deligations_per_pool_epoch_intervall( + async fn delegations_per_pool_epoch_intervall( &self, pool: &str, start_epoch: i64, end_epoch: i64, ) -> Result, DataProviderError> { - Ok(api::deligations_per_pool_for_epochs( + Ok(api::delegations_per_pool_for_epochs( self, pool, start_epoch, diff --git a/src/carb/api.rs b/src/carb/api.rs index 6cabc61..6084a43 100644 --- a/src/carb/api.rs +++ b/src/carb/api.rs @@ -22,7 +22,7 @@ pub fn select_addr_of_first_transaction( bfp: &CarbProvider, stake_address_in: &str, ) -> Result { - Ok("".to_owned()) + todo!() } /// get all utxos of an address @@ -31,7 +31,7 @@ pub fn utxo_by_dataumhash( addr: &str, datumhash: &Vec, ) -> Result { - Err(DataProviderCarbError::Custom("not implemented".to_string())) + todo!() } /// returns Utxo of a certain datumhash on an address @@ -40,7 +40,7 @@ pub fn utxo_by_txid( txhash: &Vec, index: i16, ) -> Result { - Err(DataProviderCarbError::Custom("not implemented".to_string())) + todo!() } /// get all utxos of an address @@ -48,7 +48,7 @@ pub fn get_address_utxos( bfp: &CarbProvider, addr: &str, ) -> Result { - Ok(dcslc::TransactionUnspentOutputs::new()) + todo!() } /// Get all utxos of a stake address @@ -56,7 +56,7 @@ pub fn get_stake_address_utxos( bfp: &CarbProvider, stake_addr: &str, ) -> Result { - Ok(dcslc::TransactionUnspentOutputs::new()) + todo!() } /// Get all utxos of a stake address @@ -64,18 +64,18 @@ pub fn asset_utxos_on_addr( bfp: &CarbProvider, addr: &str, ) -> Result { - Ok(dcslc::TransactionUnspentOutputs::new()) + todo!() } pub fn find_datums_for_tx( bfp: &CarbProvider, txid: &Vec, ) -> Result, DataProviderError> { - todo!(); + todo!() } pub fn slot(bfp: &CarbProvider) -> Result { - Ok(0) + todo!() } pub fn stakers_on_pool( @@ -83,16 +83,16 @@ pub fn stakers_on_pool( pool: &str, epoch: i32, ) -> Result, DataProviderCarbError> { - todo!(); + todo!() } -pub fn deligations_per_pool_for_epochs( +pub fn delegations_per_pool_for_epochs( bfp: &CarbProvider, pool: &str, start_epoch: i64, end_epoch: i64, ) -> Result, DataProviderCarbError> { - todo!(); + todo!() } pub fn pool_total_stake( @@ -112,7 +112,7 @@ pub fn fingerprint( policy: &str, tokenname: &str, ) -> Result { - Ok("".to_owned()) + todo!() } pub fn token_info( @@ -141,7 +141,7 @@ pub fn check_stakeaddr_registered( bfp: &CarbProvider, stake_addr_in: &str, ) -> Result { - Ok(false) + todo!() } pub fn lookup_token_holders( @@ -163,26 +163,17 @@ pub fn mint_metadata( bfp: &CarbProvider, fingerprint_in: &str, ) -> Result { - Ok(TokenInfoView { - fingerprint: "".to_owned(), - policy: hex::encode(""), - tokenname: "".to_owned(), - meta_key: None, - json: None, - txhash: None, - quantity: None, - mint_slot: None, - }) + todo!() } pub fn pool_valid(bfp: &CarbProvider, pool_id: &str) -> Result { - Ok(true) + todo!() } pub fn txhash_spent(bfp: &CarbProvider, txhash: &str) -> Result { let txh_b = hex::decode(txhash)?; - Ok(false) + todo!() } pub fn retrieve_staked_amount ( @@ -190,14 +181,14 @@ pub fn retrieve_staked_amount ( epoch: i32, stake_addr: &str, ) -> Result { - Ok(BigDecimal::from(0)) + todo!() } pub fn retrieve_generated_rewards ( bfp: &CarbProvider, stake_addr: &str, ) -> Result, DataProviderError> { - Ok(vec![]) + todo!() } pub fn pool_vrf_key_hash ( diff --git a/src/dbsync/mod.rs b/src/dbsync.rs similarity index 98% rename from src/dbsync/mod.rs rename to src/dbsync.rs index 5b01496..6f6e6b2 100644 --- a/src/dbsync/mod.rs +++ b/src/dbsync.rs @@ -137,13 +137,13 @@ impl super::provider::CardanoDataProvider for DBSyncProvider { Ok(api::stakers_on_pool(self, pool, epoch)?) } - async fn deligations_per_pool_epoch_intervall( + async fn delegations_per_pool_epoch_intervall( &self, pool: &str, start_epoch: i64, end_epoch: i64, ) -> Result, DataProviderError> { - Ok(api::deligations_per_pool_for_epochs( + Ok(api::delegations_per_pool_for_epochs( self, pool, start_epoch, diff --git a/src/dbsync/api.rs b/src/dbsync/api.rs index 1cfef1a..3bc0e52 100644 --- a/src/dbsync/api.rs +++ b/src/dbsync/api.rs @@ -433,7 +433,7 @@ pub fn stakers_on_pool( Ok(pool_stake) } -pub fn deligations_per_pool_for_epochs( +pub fn delegations_per_pool_for_epochs( dbs: &DBSyncProvider, pool: &str, start_epoch: i64, diff --git a/src/grpc/mod.rs b/src/grpc/mod.rs index 075b901..edbc36f 100644 --- a/src/grpc/mod.rs +++ b/src/grpc/mod.rs @@ -215,7 +215,7 @@ impl ChainFollowerRequestService for AyaCardanoRPCServer { Ok(Response::new(reply)) // Send back our formatted greeting } - async fn deligator_stake_event( + async fn delegator_stake_event( &self, request: Request, ) -> Result, Status> { @@ -229,7 +229,7 @@ impl ChainFollowerRequestService for AyaCardanoRPCServer { Ok(Response::new(reply)) // Send back our formatted greeting } - async fn deligator_staked( + async fn delegator_staked( &self, request: Request, ) -> Result, Status> { @@ -242,7 +242,7 @@ impl ChainFollowerRequestService for AyaCardanoRPCServer { Ok(Response::new(reply)) // Send back our formatted greeting } - async fn deligator_unstake_event( + async fn delegator_unstake_event( &self, request: Request, ) -> Result, Status> { @@ -256,7 +256,7 @@ impl ChainFollowerRequestService for AyaCardanoRPCServer { Ok(Response::new(reply)) // Send back our formatted greeting } - async fn deligator_unbonding( + async fn delegator_unbonding( &self, request: Request, ) -> Result, Status> { @@ -269,7 +269,7 @@ impl ChainFollowerRequestService for AyaCardanoRPCServer { Ok(Response::new(reply)) // Send back our formatted greeting } - async fn deligator_unbonding_event( + async fn delegator_unbonding_event( &self, request: Request, ) -> Result, Status> { diff --git a/src/koios/mod.rs b/src/koios.rs similarity index 98% rename from src/koios/mod.rs rename to src/koios.rs index 1c4fec6..c8ca04a 100644 --- a/src/koios/mod.rs +++ b/src/koios.rs @@ -127,13 +127,13 @@ impl super::provider::CardanoDataProvider for KoiosProvider { Ok(api::stakers_on_pool(self, pool, epoch)?) } - async fn deligations_per_pool_epoch_intervall( + async fn delegations_per_pool_epoch_intervall( &self, pool: &str, start_epoch: i64, end_epoch: i64, ) -> Result, DataProviderError> { - Ok(api::deligations_per_pool_for_epochs( + Ok(api::delegations_per_pool_for_epochs( self, pool, start_epoch, diff --git a/src/koios/api.rs b/src/koios/api.rs index b8055a9..ef29097 100644 --- a/src/koios/api.rs +++ b/src/koios/api.rs @@ -20,7 +20,7 @@ pub fn select_addr_of_first_transaction( bfp: &KoiosProvider, stake_address_in: &str, ) -> Result { - Ok("".to_owned()) + todo!() } /// get all utxos of an address @@ -29,9 +29,7 @@ pub fn get_utxo_by_dataumhash( addr: &str, datumhash: &Vec, ) -> Result { - Err(DataProviderKoiosError::Custom( - "not implemented".to_string(), - )) + todo!() } /// get all utxos of an address @@ -40,9 +38,7 @@ pub fn utxo_by_txid( txhash: &Vec, index: i16, ) -> Result { - Err(DataProviderKoiosError::Custom( - "not implemented".to_string(), - )) + todo!() } /// get all utxos of an address @@ -50,7 +46,7 @@ pub fn get_address_utxos( bfp: &KoiosProvider, addr: &str, ) -> Result { - Ok(dcslc::TransactionUnspentOutputs::new()) + todo!() } /// Get all utxos of a stake address @@ -58,7 +54,7 @@ pub fn get_stake_address_utxos( bfp: &KoiosProvider, stake_addr: &str, ) -> Result { - Ok(dcslc::TransactionUnspentOutputs::new()) + todo!() } /// Get all utxos of a stake address @@ -66,7 +62,7 @@ pub fn asset_utxos_on_addr( bfp: &KoiosProvider, addr: &str, ) -> Result { - Ok(dcslc::TransactionUnspentOutputs::new()) + todo!() } pub fn find_datums_for_tx( @@ -77,7 +73,7 @@ pub fn find_datums_for_tx( } pub fn slot(bfp: &KoiosProvider) -> Result { - Ok(0) + todo!() } pub fn stakers_on_pool( @@ -85,16 +81,16 @@ pub fn stakers_on_pool( pool: &str, epoch: i32, ) -> Result, DataProviderKoiosError> { - todo!(); + todo!() } -pub fn deligations_per_pool_for_epochs( +pub fn delegations_per_pool_for_epochs( bfp: &KoiosProvider, pool: &str, start_epoch: i64, end_epoch: i64, ) -> Result, DataProviderKoiosError> { - todo!(); + todo!() } pub fn pool_total_stake( @@ -102,11 +98,11 @@ pub fn pool_total_stake( pool: &str, epoch: i32, ) -> Result { - Ok(0) + todo!() } pub fn current_epoch(bfp: &KoiosProvider) -> Result { - Ok(0) + todo!() } pub fn fingerprint( @@ -114,7 +110,7 @@ pub fn fingerprint( policy: &str, tokenname: &str, ) -> Result { - Ok("".to_owned()) + todo!() } pub fn token_info( @@ -143,7 +139,7 @@ pub fn check_stakeaddr_registered( bfp: &KoiosProvider, stake_addr_in: &str, ) -> Result { - Ok(false) + todo!() } pub fn lookup_token_holders( @@ -165,26 +161,17 @@ pub fn mint_metadata( bfp: &KoiosProvider, fingerprint_in: &str, ) -> Result { - Ok(TokenInfoView { - fingerprint: "".to_owned(), - policy: hex::encode(""), - tokenname: "".to_owned(), - meta_key: None, - json: None, - txhash: None, - quantity: None, - mint_slot: None, - }) + todo!() } pub fn pool_valid(bfp: &KoiosProvider, pool_id: &str) -> Result { - Ok(true) + todo!() } pub fn txhash_spent(bfp: &KoiosProvider, txhash: &str) -> Result { let txh_b = hex::decode(txhash)?; - Ok(false) + todo!() } pub fn retrieve_staked_amount ( @@ -192,14 +179,14 @@ pub fn retrieve_staked_amount ( epoch: i32, stake_addr: &str, ) -> Result { - Ok(BigDecimal::from(0)) + todo!() } pub fn retrieve_generated_rewards ( bfp: &KoiosProvider, stake_addr: &str, ) -> Result, DataProviderKoiosError> { - Ok(vec![]) + todo!() } pub fn pool_vrf_key_hash( diff --git a/src/proto/aya_cardano.proto b/src/proto/aya_cardano.proto index 9ae13b0..4a38e25 100644 --- a/src/proto/aya_cardano.proto +++ b/src/proto/aya_cardano.proto @@ -8,11 +8,11 @@ service ChainFollowerRequestService { rpc AyaValidatorStake (StakeRequest) returns (StateResponse); rpc AyaValidatorRegistrationEvent (ValidatorRequest) returns (EventResponse); rpc AyaValidatorUnregistrationEvent (ValidatorRequest) returns (EventResponse); - rpc DeligatorStakeEvent (StakeRequest) returns (EventResponse); - rpc DeligatorStaked (StakeRequest) returns (StateResponse); - rpc DeligatorUnstakeEvent (StakeRequest) returns (EventResponse); - rpc DeligatorUnbonding (StakeRequest) returns (StateResponse); - rpc DeligatorUnbondingEvent (StakeRequest) returns (EventResponse); + rpc DelegatorStakeEvent (StakeRequest) returns (EventResponse); + rpc DelegatorStaked (StakeRequest) returns (StateResponse); + rpc DelegatorUnstakeEvent (StakeRequest) returns (EventResponse); + rpc DelegatorUnbonding (StakeRequest) returns (StateResponse); + rpc DelegatorUnbondingEvent (StakeRequest) returns (EventResponse); }; enum EpochRequestType { diff --git a/src/proto/aya_cardano.rs b/src/proto/aya_cardano.rs index 2b15305..42bb987 100644 --- a/src/proto/aya_cardano.rs +++ b/src/proto/aya_cardano.rs @@ -502,7 +502,7 @@ pub mod chain_follower_request_service_client { ); self.inner.unary(req, path, codec).await } - pub async fn deligator_stake_event( + pub async fn delegator_stake_event( &mut self, request: impl tonic::IntoRequest, ) -> std::result::Result, tonic::Status> { @@ -517,19 +517,19 @@ pub mod chain_follower_request_service_client { })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/aya_cardano.ChainFollowerRequestService/DeligatorStakeEvent", + "/aya_cardano.ChainFollowerRequestService/DelegatorStakeEvent", ); let mut req = request.into_request(); req.extensions_mut() .insert( GrpcMethod::new( "aya_cardano.ChainFollowerRequestService", - "DeligatorStakeEvent", + "DelegatorStakeEvent", ), ); self.inner.unary(req, path, codec).await } - pub async fn deligator_staked( + pub async fn delegator_staked( &mut self, request: impl tonic::IntoRequest, ) -> std::result::Result, tonic::Status> { @@ -544,19 +544,19 @@ pub mod chain_follower_request_service_client { })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/aya_cardano.ChainFollowerRequestService/DeligatorStaked", + "/aya_cardano.ChainFollowerRequestService/DelegatorStaked", ); let mut req = request.into_request(); req.extensions_mut() .insert( GrpcMethod::new( "aya_cardano.ChainFollowerRequestService", - "DeligatorStaked", + "DelegatorStaked", ), ); self.inner.unary(req, path, codec).await } - pub async fn deligator_unstake_event( + pub async fn delegator_unstake_event( &mut self, request: impl tonic::IntoRequest, ) -> std::result::Result, tonic::Status> { @@ -571,19 +571,19 @@ pub mod chain_follower_request_service_client { })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/aya_cardano.ChainFollowerRequestService/DeligatorUnstakeEvent", + "/aya_cardano.ChainFollowerRequestService/DelegatorUnstakeEvent", ); let mut req = request.into_request(); req.extensions_mut() .insert( GrpcMethod::new( "aya_cardano.ChainFollowerRequestService", - "DeligatorUnstakeEvent", + "DelegatorUnstakeEvent", ), ); self.inner.unary(req, path, codec).await } - pub async fn deligator_unbonding( + pub async fn delegator_unbonding( &mut self, request: impl tonic::IntoRequest, ) -> std::result::Result, tonic::Status> { @@ -598,19 +598,19 @@ pub mod chain_follower_request_service_client { })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/aya_cardano.ChainFollowerRequestService/DeligatorUnbonding", + "/aya_cardano.ChainFollowerRequestService/DelegatorUnbonding", ); let mut req = request.into_request(); req.extensions_mut() .insert( GrpcMethod::new( "aya_cardano.ChainFollowerRequestService", - "DeligatorUnbonding", + "DelegatorUnbonding", ), ); self.inner.unary(req, path, codec).await } - pub async fn deligator_unbonding_event( + pub async fn delegator_unbonding_event( &mut self, request: impl tonic::IntoRequest, ) -> std::result::Result, tonic::Status> { @@ -625,14 +625,14 @@ pub mod chain_follower_request_service_client { })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( - "/aya_cardano.ChainFollowerRequestService/DeligatorUnbondingEvent", + "/aya_cardano.ChainFollowerRequestService/DelegatorUnbondingEvent", ); let mut req = request.into_request(); req.extensions_mut() .insert( GrpcMethod::new( "aya_cardano.ChainFollowerRequestService", - "DeligatorUnbondingEvent", + "DelegatorUnbondingEvent", ), ); self.inner.unary(req, path, codec).await @@ -666,23 +666,23 @@ pub mod chain_follower_request_service_server { &self, request: tonic::Request, ) -> std::result::Result, tonic::Status>; - async fn deligator_stake_event( + async fn delegator_stake_event( &self, request: tonic::Request, ) -> std::result::Result, tonic::Status>; - async fn deligator_staked( + async fn delegator_staked( &self, request: tonic::Request, ) -> std::result::Result, tonic::Status>; - async fn deligator_unstake_event( + async fn delegator_unstake_event( &self, request: tonic::Request, ) -> std::result::Result, tonic::Status>; - async fn deligator_unbonding( + async fn delegator_unbonding( &self, request: tonic::Request, ) -> std::result::Result, tonic::Status>; - async fn deligator_unbonding_event( + async fn delegator_unbonding_event( &self, request: tonic::Request, ) -> std::result::Result, tonic::Status>; @@ -1011,15 +1011,15 @@ pub mod chain_follower_request_service_server { }; Box::pin(fut) } - "/aya_cardano.ChainFollowerRequestService/DeligatorStakeEvent" => { + "/aya_cardano.ChainFollowerRequestService/DelegatorStakeEvent" => { #[allow(non_camel_case_types)] - struct DeligatorStakeEventSvc( + struct DelegatorStakeEventSvc( pub Arc, ); impl< T: ChainFollowerRequestService, > tonic::server::UnaryService - for DeligatorStakeEventSvc { + for DelegatorStakeEventSvc { type Response = super::EventResponse; type Future = BoxFuture< tonic::Response, @@ -1031,7 +1031,7 @@ pub mod chain_follower_request_service_server { ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - (*inner).deligator_stake_event(request).await + (*inner).delegator_stake_event(request).await }; Box::pin(fut) } @@ -1043,7 +1043,7 @@ pub mod chain_follower_request_service_server { let inner = self.inner.clone(); let fut = async move { let inner = inner.0; - let method = DeligatorStakeEventSvc(inner); + let method = DelegatorStakeEventSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -1059,15 +1059,15 @@ pub mod chain_follower_request_service_server { }; Box::pin(fut) } - "/aya_cardano.ChainFollowerRequestService/DeligatorStaked" => { + "/aya_cardano.ChainFollowerRequestService/DelegatorStaked" => { #[allow(non_camel_case_types)] - struct DeligatorStakedSvc( + struct DelegatorStakedSvc( pub Arc, ); impl< T: ChainFollowerRequestService, > tonic::server::UnaryService - for DeligatorStakedSvc { + for DelegatorStakedSvc { type Response = super::StateResponse; type Future = BoxFuture< tonic::Response, @@ -1079,7 +1079,7 @@ pub mod chain_follower_request_service_server { ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - (*inner).deligator_staked(request).await + (*inner).delegator_staked(request).await }; Box::pin(fut) } @@ -1091,7 +1091,7 @@ pub mod chain_follower_request_service_server { let inner = self.inner.clone(); let fut = async move { let inner = inner.0; - let method = DeligatorStakedSvc(inner); + let method = DelegatorStakedSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -1107,15 +1107,15 @@ pub mod chain_follower_request_service_server { }; Box::pin(fut) } - "/aya_cardano.ChainFollowerRequestService/DeligatorUnstakeEvent" => { + "/aya_cardano.ChainFollowerRequestService/DelegatorUnstakeEvent" => { #[allow(non_camel_case_types)] - struct DeligatorUnstakeEventSvc( + struct DelegatorUnstakeEventSvc( pub Arc, ); impl< T: ChainFollowerRequestService, > tonic::server::UnaryService - for DeligatorUnstakeEventSvc { + for DelegatorUnstakeEventSvc { type Response = super::EventResponse; type Future = BoxFuture< tonic::Response, @@ -1127,7 +1127,7 @@ pub mod chain_follower_request_service_server { ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - (*inner).deligator_unstake_event(request).await + (*inner).delegator_unstake_event(request).await }; Box::pin(fut) } @@ -1139,7 +1139,7 @@ pub mod chain_follower_request_service_server { let inner = self.inner.clone(); let fut = async move { let inner = inner.0; - let method = DeligatorUnstakeEventSvc(inner); + let method = DelegatorUnstakeEventSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -1155,15 +1155,15 @@ pub mod chain_follower_request_service_server { }; Box::pin(fut) } - "/aya_cardano.ChainFollowerRequestService/DeligatorUnbonding" => { + "/aya_cardano.ChainFollowerRequestService/DelegatorUnbonding" => { #[allow(non_camel_case_types)] - struct DeligatorUnbondingSvc( + struct DelegatorUnbondingSvc( pub Arc, ); impl< T: ChainFollowerRequestService, > tonic::server::UnaryService - for DeligatorUnbondingSvc { + for DelegatorUnbondingSvc { type Response = super::StateResponse; type Future = BoxFuture< tonic::Response, @@ -1175,7 +1175,7 @@ pub mod chain_follower_request_service_server { ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - (*inner).deligator_unbonding(request).await + (*inner).delegator_unbonding(request).await }; Box::pin(fut) } @@ -1187,7 +1187,7 @@ pub mod chain_follower_request_service_server { let inner = self.inner.clone(); let fut = async move { let inner = inner.0; - let method = DeligatorUnbondingSvc(inner); + let method = DelegatorUnbondingSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( @@ -1203,15 +1203,15 @@ pub mod chain_follower_request_service_server { }; Box::pin(fut) } - "/aya_cardano.ChainFollowerRequestService/DeligatorUnbondingEvent" => { + "/aya_cardano.ChainFollowerRequestService/DelegatorUnbondingEvent" => { #[allow(non_camel_case_types)] - struct DeligatorUnbondingEventSvc( + struct DelegatorUnbondingEventSvc( pub Arc, ); impl< T: ChainFollowerRequestService, > tonic::server::UnaryService - for DeligatorUnbondingEventSvc { + for DelegatorUnbondingEventSvc { type Response = super::EventResponse; type Future = BoxFuture< tonic::Response, @@ -1223,7 +1223,7 @@ pub mod chain_follower_request_service_server { ) -> Self::Future { let inner = Arc::clone(&self.0); let fut = async move { - (*inner).deligator_unbonding_event(request).await + (*inner).delegator_unbonding_event(request).await }; Box::pin(fut) } @@ -1235,7 +1235,7 @@ pub mod chain_follower_request_service_server { let inner = self.inner.clone(); let fut = async move { let inner = inner.0; - let method = DeligatorUnbondingEventSvc(inner); + let method = DelegatorUnbondingEventSvc(inner); let codec = tonic::codec::ProstCodec::default(); let mut grpc = tonic::server::Grpc::new(codec) .apply_compression_config( diff --git a/src/provider.rs b/src/provider.rs index d1f672d..b5d72b4 100644 --- a/src/provider.rs +++ b/src/provider.rs @@ -70,7 +70,7 @@ pub trait CardanoDataProvider { epoch: i32, ) -> Result, DataProviderError>; /// return the delegations for a pool in an epoch intervall - async fn deligations_per_pool_epoch_intervall( + async fn delegations_per_pool_epoch_intervall( &self, pool: &str, start_epoch: i64, @@ -310,14 +310,14 @@ impl CardanoData self.provider().stakers_on_pool(pool, epoch).await } - async fn deligations_per_pool_epoch_intervall( + async fn delegations_per_pool_epoch_intervall( &self, pool: &str, start_epoch: i64, end_epoch: i64, ) -> Result, DataProviderError> { self.provider() - .deligations_per_pool_epoch_intervall(pool, start_epoch, end_epoch) + .delegations_per_pool_epoch_intervall(pool, start_epoch, end_epoch) .await } From b48d0084f06e7d7254b2f68aa0929915aab7af66 Mon Sep 17 00:00:00 2001 From: Amir Abdin Date: Tue, 10 Oct 2023 00:50:57 +0200 Subject: [PATCH 06/12] Make custom enums compilable --- Cargo.toml | 4 ++-- diesel.toml | 1 + src/bin/server.rs | 1 + src/dbsync/api.rs | 14 ++++++++------ src/dbsync/models.rs | 10 ++++++---- src/dbsync/schema.rs | 24 +++++++++++++++++------- src/server/handler/handler_rest/info.rs | 2 +- src/server/handler/handler_rest/mod.rs | 2 +- 8 files changed, 37 insertions(+), 21 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index c1c91d3..c4b0526 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -32,7 +32,7 @@ reqwest = { version = "0.11", default-features = false, features = [ http = "0.2.6" toml = "0.5.9" base64 = "0.21.4" -diesel = { version = "2.0.0", features = [ +diesel = { version = "2.1.3", features = [ "postgres", "numeric", "chrono", @@ -40,7 +40,7 @@ diesel = { version = "2.0.0", features = [ "r2d2", "serde_json", ] } -diesel-derive-enum = { version = "2.0.0", features = ["postgres"] } +diesel-derive-enum = { version = "2.1.0", features = ["postgres"] } bigdecimal = { version = "0.4.0", features = ["serde"] } chrono = { version = "0.4.19", features = ["serde"] } config = { version = "0.13.0", default-features = false, features = [ diff --git a/diesel.toml b/diesel.toml index 98ba5a1..6d581ea 100644 --- a/diesel.toml +++ b/diesel.toml @@ -3,3 +3,4 @@ [print_schema] file = "src/dbsync/schema.rs" +custom_type_derives = ["diesel::query_builder::QueryId"] \ No newline at end of file diff --git a/src/bin/server.rs b/src/bin/server.rs index 0ce3344..5686e45 100644 --- a/src/bin/server.rs +++ b/src/bin/server.rs @@ -1,3 +1,4 @@ +#![recursion_limit = "256"] pub type Error = Box; pub type Result = std::result::Result; diff --git a/src/dbsync/api.rs b/src/dbsync/api.rs index 3bc0e52..98b11bd 100644 --- a/src/dbsync/api.rs +++ b/src/dbsync/api.rs @@ -1,6 +1,7 @@ use super::error::DataProviderDBSyncError; -use super::models::{PoolHash, PoolRetire, Rewardtype, UnspentUtxo, UtxoView}; +use super::models::{PoolHash, PoolRetire, UnspentUtxo, UtxoView}; use super::schema::*; +use super::models::RewardType; use crate::models::{ CDPDatum, CardanoNativeAssetView, DelegationView, HoldingWalletView, PoolView, RewardView, ScriptView, StakeDelegationView, StakeDeregistrationView, StakeRegistrationView, TokenInfoView, @@ -10,6 +11,7 @@ use crate::models::{ use crate::DBSyncProvider; use bigdecimal::{BigDecimal, FromPrimitive, ToPrimitive}; use dcslc::TransactionUnspentOutputs; +use diesel::dsl::count_star; use diesel::prelude::*; use log::debug; use std::str::FromStr; @@ -1886,13 +1888,13 @@ pub async fn pool_live_delegators( ) -> Result { Ok( reward::table - .inner_join(pool_hash::table.on(pool_hash::id.nullable().eq(reward::pool_id))) + .filter(reward::pool_id.is_not_null()) + .inner_join(pool_hash::table.on(pool_hash::id.eq(reward::pool_id.assume_not_null()))) .filter(pool_hash::view.eq(pool_hash.to_string())) .filter(reward::earned_epoch.eq(current_epoch(dbs).unwrap() as i64)) - // .filter(reward::type_.eq(Rewardtype::Member)) TODO: FixMe + .filter(reward::type_.eq(RewardType::Member)) // TODO: FixMe .count() - .get_result::(&mut dbs.connect().unwrap() - ).unwrap() + .get_result::(&mut dbs.connect()?)? ) } @@ -2513,7 +2515,7 @@ mod tests { let _func_value = super::pool_live_delegators(dp.provider(), pool_hash).await.unwrap(); // TODO:: FixMe let _manual_value = 104; - // assert_eq!(_func_value, _manual_value); // TODO: make this unit test work + assert_eq!(_func_value, _manual_value); // TODO: make this unit test work } #[tokio::test] diff --git a/src/dbsync/models.rs b/src/dbsync/models.rs index ca433b9..76e3d33 100644 --- a/src/dbsync/models.rs +++ b/src/dbsync/models.rs @@ -34,9 +34,10 @@ pub enum Scriptpurposetype { #[db_rename = "reward"] Reward, } -#[derive(Debug, Clone, DbEnum, QueryId)] -#[ExistingTypePath = "crate::dbsync::schema::sql_types::Rewardtype"] -pub enum Rewardtype { + +#[derive(Clone, Copy, Debug, DbEnum, PartialEq, Eq)] // Debug, Clone, QueryId +#[ExistingTypePath = "crate::dbsync::schema::sql_types::RewardTypeEnum"] +pub enum RewardType { #[db_rename = "leader"] Leader, #[db_rename = "member"] @@ -48,6 +49,7 @@ pub enum Rewardtype { #[db_rename = "refund"] Refund, } + #[derive(Debug, Clone, DbEnum, QueryId, serde::Serialize, serde::Deserialize)] #[ExistingTypePath = "crate::dbsync::schema::sql_types::Scripttype"] pub enum Scripttype { @@ -640,7 +642,7 @@ pub struct ReservedPoolTicker { pub struct Reward { pub id: i64, pub addr_id: i64, - pub type_: Rewardtype, + pub type_: RewardType, pub amount: BigDecimal, pub earned_epoch: i64, pub spendable_epoch: i64, diff --git a/src/dbsync/schema.rs b/src/dbsync/schema.rs index 60af444..73eb6fb 100644 --- a/src/dbsync/schema.rs +++ b/src/dbsync/schema.rs @@ -1,17 +1,24 @@ pub mod sql_types { - #[derive(diesel::sql_types::SqlType)] + use diesel::{ + sql_types::SqlType, + query_builder::QueryId + }; + + use diesel_derive_enum::DbEnum; + + #[derive(SqlType, QueryId)] #[diesel(postgres_type(name = "Syncstatetype"))] pub struct Syncstatetype; - #[derive(diesel::sql_types::SqlType)] + #[derive(SqlType, QueryId)] #[diesel(postgres_type(name = "Scriptpurposetype"))] pub struct Scriptpurposetype; - #[derive(diesel::sql_types::SqlType)] - #[diesel(postgres_type(name = "Rewardtype"))] - pub struct Rewardtype; + #[derive(SqlType, QueryId)] + #[diesel(postgres_type(name = "rewardtype"))] + pub struct RewardTypeEnum; - #[derive(diesel::sql_types::SqlType)] + #[derive(SqlType, QueryId)] #[diesel(postgres_type(name = "Scripttype"))] pub struct Scripttype; } @@ -469,11 +476,14 @@ table! { } table! { + use diesel::sql_types::*; + use super::sql_types::RewardTypeEnum; + reward (id) { id -> Int8, addr_id -> Int8, #[sql_name = "type"] - type_ -> crate::dbsync::schema::sql_types::Rewardtype, + type_ -> RewardTypeEnum, amount -> Numeric, earned_epoch -> Int8, spendable_epoch -> Int8, diff --git a/src/server/handler/handler_rest/info.rs b/src/server/handler/handler_rest/info.rs index 21f3a18..98559ab 100644 --- a/src/server/handler/handler_rest/info.rs +++ b/src/server/handler/handler_rest/info.rs @@ -598,7 +598,7 @@ pub async fn pool_blocks_current_epoch( Ok(rweb::Json::from(json!(pool_blocks_current_epoch))) } -// #[get("pool/live_delegators/{pool_hash}")] // TODO: FixMe (start with dbsync/api.rs) +// // #[get("pool/live_delegators/{pool_hash}")] // TODO: FixMe (start with dbsync/api.rs) #[get("/pool/declared_pledge/{pool_hash}")] #[openapi( diff --git a/src/server/handler/handler_rest/mod.rs b/src/server/handler/handler_rest/mod.rs index f427310..2840bd0 100644 --- a/src/server/handler/handler_rest/mod.rs +++ b/src/server/handler/handler_rest/mod.rs @@ -27,7 +27,7 @@ use rweb::*; is_nft, retrieve_staked_amount, retrieve_generated_rewards, - pool_vrf_key_hash, + pool_vrf_key_hash, pool_blocks_minted, pool_blocks_current_epoch, pool_declared_pledge, From 44f505f31e58094b32a46537cfb2df5389dbb688 Mon Sep 17 00:00:00 2001 From: Amir Abdin Date: Tue, 10 Oct 2023 02:38:03 +0200 Subject: [PATCH 07/12] Add 2 pool API:s, incl. custom enum --- src/blockfrost.rs | 14 +++++ src/blockfrost/api.rs | 14 +++++ src/carb.rs | 14 +++++ src/carb/api.rs | 14 +++++ src/dbsync.rs | 14 +++++ src/dbsync/api.rs | 82 +++++++++++++++++-------- src/koios.rs | 14 +++++ src/koios/api.rs | 14 +++++ src/provider.rs | 24 ++++++++ src/server/handler/handler_rest/info.rs | 45 +++++++++++++- src/server/handler/handler_rest/mod.rs | 9 ++- 11 files changed, 229 insertions(+), 29 deletions(-) diff --git a/src/blockfrost.rs b/src/blockfrost.rs index 673430a..84c83ef 100644 --- a/src/blockfrost.rs +++ b/src/blockfrost.rs @@ -290,6 +290,20 @@ impl super::provider::CardanoDataProvider for BlockfrostProvider { Ok(api::pool_blocks_current_epoch(self, pool_hash)?) } + async fn pool_reward_recipients( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_reward_recipients(self, pool_hash)?) + } + + async fn pool_last_reward_earned_epoch( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_last_reward_earned_epoch(self, pool_hash)?) + } + async fn pool_declared_pledge( &self, pool_hash: &str, diff --git a/src/blockfrost/api.rs b/src/blockfrost/api.rs index b25688c..848ef38 100644 --- a/src/blockfrost/api.rs +++ b/src/blockfrost/api.rs @@ -267,6 +267,20 @@ pub fn pool_blocks_current_epoch( todo!() } +pub fn pool_reward_recipients( + bfp: &BlockfrostProvider, + pool_hash: &str, +) -> Result { + todo!() +} + +pub fn pool_last_reward_earned_epoch( + bfp: &BlockfrostProvider, + pool_hash: &str, +) -> Result { + todo!() +} + pub fn pool_declared_pledge( bfp: &BlockfrostProvider, pool_hash: &str, diff --git a/src/carb.rs b/src/carb.rs index 45edab8..1fa4919 100644 --- a/src/carb.rs +++ b/src/carb.rs @@ -278,6 +278,20 @@ impl super::provider::CardanoDataProvider for CarbProvider { Ok(api::pool_blocks_current_epoch(self, pool_hash)?) } + async fn pool_reward_recipients( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_reward_recipients(self, pool_hash)?) + } + + async fn pool_last_reward_earned_epoch( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_last_reward_earned_epoch(self, pool_hash)?) + } + async fn pool_declared_pledge( &self, pool_hash: &str, diff --git a/src/carb/api.rs b/src/carb/api.rs index 6084a43..b32e570 100644 --- a/src/carb/api.rs +++ b/src/carb/api.rs @@ -212,6 +212,20 @@ pub fn pool_blocks_current_epoch( todo!() } +pub fn pool_reward_recipients( + bfp: &CarbProvider, + pool_hash: &str, +) -> Result { + todo!() +} + +pub fn pool_last_reward_earned_epoch( + bfp: &CarbProvider, + pool_hash: &str, +) -> Result { + todo!() +} + pub fn pool_declared_pledge( bfp: &CarbProvider, pool_hash: &str, diff --git a/src/dbsync.rs b/src/dbsync.rs index 6f6e6b2..7d6339f 100644 --- a/src/dbsync.rs +++ b/src/dbsync.rs @@ -286,6 +286,20 @@ impl super::provider::CardanoDataProvider for DBSyncProvider { Ok(api::pool_blocks_current_epoch(self, pool_hash).await?) } + async fn pool_reward_recipients( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_reward_recipients(self, pool_hash).await?) + } + + async fn pool_last_reward_earned_epoch( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_last_reward_earned_epoch(self, pool_hash).await?) + } + async fn pool_declared_pledge( &self, pool_hash: &str, diff --git a/src/dbsync/api.rs b/src/dbsync/api.rs index 98b11bd..e5309e4 100644 --- a/src/dbsync/api.rs +++ b/src/dbsync/api.rs @@ -1880,9 +1880,11 @@ pub async fn pool_blocks_current_epoch( ) } -/// The quantity of delegators that are currently delegating -/// to the given stake pool. -pub async fn pool_live_delegators( +/// The quantity of delegators that received rewards last time +/// the given pool was a slot leader. This can be used as an +/// estimation of how many are currently delegating on the +/// given pool. +pub async fn pool_reward_recipients( dbs: &DBSyncProvider, pool_hash: &str, ) -> Result { @@ -1891,13 +1893,31 @@ pub async fn pool_live_delegators( .filter(reward::pool_id.is_not_null()) .inner_join(pool_hash::table.on(pool_hash::id.eq(reward::pool_id.assume_not_null()))) .filter(pool_hash::view.eq(pool_hash.to_string())) - .filter(reward::earned_epoch.eq(current_epoch(dbs).unwrap() as i64)) - .filter(reward::type_.eq(RewardType::Member)) // TODO: FixMe + .filter(reward::earned_epoch.eq( + pool_last_reward_earned_epoch(dbs, pool_hash).await? + )) + .filter(reward::type_.eq(RewardType::Member)) .count() .get_result::(&mut dbs.connect()?)? ) } +/// When was the last time (epoch) the given pool was a slot leader? +pub async fn pool_last_reward_earned_epoch( + dbs: &DBSyncProvider, + pool_hash: &str, +) -> Result { + Ok( + reward::table + .filter(reward::pool_id.is_not_null()) + .inner_join(pool_hash::table.on(pool_hash::id.eq(reward::pool_id.assume_not_null()))) + .filter(pool_hash::view.eq(pool_hash.to_string())) + .order(reward::earned_epoch.desc()) + .select(reward::earned_epoch) + .first::(&mut dbs.connect()?)? + ) +} + /// the amount of Ada that the owner of the given stake pool /// has pledged to stake in the given pool, according to the /// pool registration certificate. @@ -2479,7 +2499,7 @@ mod tests { let _func_value = hex::encode(super::pool_vrf_key_hash(dp.provider(), pool_hash).await.unwrap()); let _manual_value = "335399acf3228243efb0fec0e43f18d61a496d4fd740fd800f9b91b5fa7d0540"; - // assert_eq!(_func_value, _manual_value); // The value change in the future. But it passed at the time of this writing. + // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2491,7 +2511,7 @@ mod tests { let _func_value = super::pool_blocks_minted(dp.provider(), pool_hash).await.unwrap(); let _manual_value = 13; - // assert_eq!(_func_value, _manual_value); // The value change in the future. But it passed at the time of this writing. + // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2503,19 +2523,31 @@ mod tests { let _func_value = super::pool_blocks_current_epoch(dp.provider(), pool_hash).await.unwrap(); let _manual_value = 25; - // assert_eq!(_func_value, _manual_value); // The value change in the future. But it passed at the time of this writing. + // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. + } + + #[tokio::test] + async fn pool_reward_recipients() { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), + })); + let pool_hash = "pool1rk2y9gx6vll8lawzdqlky5p2a3ypzsxg07arg8gmhkjj2905035"; + let _func_value = super::pool_reward_recipients(dp.provider(), pool_hash).await.unwrap(); + let _manual_value = 207; + + // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] - async fn pool_live_delegators() { + async fn pool_last_reward_earned_epoch() { let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), })); let pool_hash = "pool1rk2y9gx6vll8lawzdqlky5p2a3ypzsxg07arg8gmhkjj2905035"; - let _func_value = super::pool_live_delegators(dp.provider(), pool_hash).await.unwrap(); // TODO:: FixMe - let _manual_value = 104; + let _func_value = super::pool_last_reward_earned_epoch(dp.provider(), pool_hash).await.unwrap(); + let _manual_value = 349; - assert_eq!(_func_value, _manual_value); // TODO: make this unit test work + // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2527,7 +2559,7 @@ mod tests { let _func_value = super::pool_declared_pledge(dp.provider(), pool_hash).await.unwrap(); let _manual_value = BigDecimal::from_str("125000000000").unwrap(); - // assert_eq!(_func_value, _manual_value); // The value change in the future. But it passed at the time of this writing. + // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2539,7 +2571,7 @@ mod tests { let _func_value = super::pool_margin_cost(dp.provider(), pool_hash).await.unwrap(); let _manual_value = 0.075; - // assert_eq!(_func_value, _manual_value); // The value change in the future. But it passed at the time of this writing. + // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2551,7 +2583,7 @@ mod tests { let _func_value = super::pool_fixed_cost(dp.provider(), pool_hash).await.unwrap(); let _manual_value = BigDecimal::from_str("340000000").unwrap(); - // assert_eq!(_func_value, _manual_value); // The value change in the future. But it passed at the time of this writing. + // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2563,7 +2595,7 @@ mod tests { let _func_value = super::pool_reward_address(dp.provider(), pool_hash).await.unwrap(); let _manual_value = "stake_test1uz5ah77y8xvnxs6cyp979hg7fhxezjw39jfrpardqymnz7sg7ea8y"; - // assert_eq!(_func_value, _manual_value); // The value change in the future. But it passed at the time of this writing. + // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2575,7 +2607,7 @@ mod tests { let _func_value = super::pool_owner(dp.provider(), pool_hash).await.unwrap(); let _manual_value = "stake_test1uz5ah77y8xvnxs6cyp979hg7fhxezjw39jfrpardqymnz7sg7ea8y"; - // assert_eq!(_func_value, _manual_value); // The value change in the future. But it passed at the time of this writing. + // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2587,7 +2619,7 @@ mod tests { let _func_value = super::pool_registration(dp.provider(), pool_hash).await.unwrap(); let _manual_value = 175; - // assert_eq!(_func_value, _manual_value); // The value change in the future. But it passed at the time of this writing. + // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2599,7 +2631,7 @@ mod tests { let func_value = super::pool_retirement(dp.provider(), pool_hash).await.unwrap(); let manual_value = 26; - assert_eq!(func_value, manual_value); // The value change in the future. But it passed at the time of this writing. + assert_eq!(func_value, manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2611,7 +2643,7 @@ mod tests { let _func_value = super::pool_url(dp.provider(), pool_hash).await.unwrap(); let _manual_value = "https://armadacardano.io/metadata.json"; - // assert_eq!(_func_value, _manual_value); // The value change in the future. But it passed at the time of this writing. + // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2623,7 +2655,7 @@ mod tests { let _func_value = super::pool_ticker(dp.provider(), pool_hash).await.unwrap(); let _manual_value = "EUSKL"; - // assert_eq!(_func_value, _manual_value); // The value change in the future. But it passed at the time of this writing. + // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2635,7 +2667,7 @@ mod tests { let _func_value = super::pool_metadata_json(dp.provider(), pool_hash).await.unwrap(); let _manual_value = json!({"name": "EUSKAL STAKE POOL TESTNET", "ticker": "EUSKL", "homepage": "https://euskalstakepool.win", "description": "EUSKAL STAKE POOL TESTNET"}); - // assert_eq!(_func_value, _manual_value); // The value change in the future. But it passed at the time of this writing. + // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2647,7 +2679,7 @@ mod tests { let _func_value = super::pool_name(dp.provider(), pool_hash).await.unwrap(); let _manual_value = "EUSKAL STAKE POOL TESTNET"; - // assert_eq!(_func_value, _manual_value); // The value change in the future. But it passed at the time of this writing. + // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2659,7 +2691,7 @@ mod tests { let _func_value = super::pool_homepage(dp.provider(), pool_hash).await.unwrap(); let _manual_value = "https://euskalstakepool.win"; - // assert_eq!(_func_value, _manual_value); // The value change in the future. But it passed at the time of this writing. + // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2671,6 +2703,6 @@ mod tests { let _func_value = super::pool_description(dp.provider(), pool_hash).await.unwrap(); let _manual_value = "EUSKAL STAKE POOL TESTNET"; - // assert_eq!(_func_value, _manual_value); // The value change in the future. But it passed at the time of this writing. + // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } } \ No newline at end of file diff --git a/src/koios.rs b/src/koios.rs index c8ca04a..02e89a8 100644 --- a/src/koios.rs +++ b/src/koios.rs @@ -276,6 +276,20 @@ impl super::provider::CardanoDataProvider for KoiosProvider { Ok(api::pool_blocks_current_epoch(self, pool_hash)?) } + async fn pool_reward_recipients( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_reward_recipients(self, pool_hash)?) + } + + async fn pool_last_reward_earned_epoch( + &self, + pool_hash: &str, + ) -> Result { + Ok(api::pool_last_reward_earned_epoch(self, pool_hash)?) + } + async fn pool_declared_pledge( &self, pool_hash: &str, diff --git a/src/koios/api.rs b/src/koios/api.rs index ef29097..7a7000a 100644 --- a/src/koios/api.rs +++ b/src/koios/api.rs @@ -210,6 +210,20 @@ pub fn pool_blocks_current_epoch( todo!() } +pub fn pool_reward_recipients( + bfp: &KoiosProvider, + pool_hash: &str, +) -> Result { + todo!() +} + +pub fn pool_last_reward_earned_epoch( + bfp: &KoiosProvider, + pool_hash: &str, +) -> Result { + todo!() +} + pub fn pool_declared_pledge( bfp: &KoiosProvider, pool_hash: &str, diff --git a/src/provider.rs b/src/provider.rs index b5d72b4..fa28409 100644 --- a/src/provider.rs +++ b/src/provider.rs @@ -150,6 +150,16 @@ pub trait CardanoDataProvider { pool_hash: &str, ) -> Result; + async fn pool_reward_recipients( + &self, + pool_hash: &str, + ) -> Result; + + async fn pool_last_reward_earned_epoch( + &self, + pool_hash: &str, + ) -> Result; + async fn pool_declared_pledge( &self, pool_hash: &str, @@ -441,6 +451,20 @@ impl CardanoData self.provider().pool_blocks_current_epoch(pool_hash).await } + async fn pool_reward_recipients ( + &self, + pool_hash: &str, + ) -> Result { + self.provider().pool_reward_recipients(pool_hash).await + } + + async fn pool_last_reward_earned_epoch ( + &self, + pool_hash: &str, + ) -> Result { + self.provider().pool_last_reward_earned_epoch(pool_hash).await + } + async fn pool_declared_pledge ( &self, pool_hash: &str, diff --git a/src/server/handler/handler_rest/info.rs b/src/server/handler/handler_rest/info.rs index 98559ab..fd84b86 100644 --- a/src/server/handler/handler_rest/info.rs +++ b/src/server/handler/handler_rest/info.rs @@ -598,7 +598,50 @@ pub async fn pool_blocks_current_epoch( Ok(rweb::Json::from(json!(pool_blocks_current_epoch))) } -// // #[get("pool/live_delegators/{pool_hash}")] // TODO: FixMe (start with dbsync/api.rs) +#[get("/pool/pool_reward_recipients/{pool_hash}")] +#[openapi( + id = "api.info.pool.pool_reward_recipients", + tags("Pool"), + summary = "The quantity of delegators that received rewards last time (epoch) the given pool was a slot leader." +)] +pub async fn pool_reward_recipients( + pool_hash: String, + #[filter = "with_auth"] _user_id: String, +) -> Result, Rejection> { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: std::env::var("DBSYNC_URL").unwrap(), + })); + + let pool_reward_recipients = dp + .pool_reward_recipients(&pool_hash) + .await + .map_err(|_| RESTError::Custom("Couldn't find the quantity of delegators that received rewards".to_string()))?; + + Ok(rweb::Json::from(json!(pool_reward_recipients))) +} + +#[get("/pool/last_reward_earned_epoch/{pool_hash}")] +#[openapi( + id = "api.info.pool.last_reward_earned_epoch", + tags("Pool"), + summary = "The last epoch when the given pool gave rewards to delegators" +)] +pub async fn pool_last_reward_earned_epoch( + pool_hash: String, + #[filter = "with_auth"] _user_id: String, +) -> Result, Rejection> { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: std::env::var("DBSYNC_URL").unwrap(), + })); + + let pool_last_reward_earned_epoch = dp + .pool_last_reward_earned_epoch(&pool_hash) + .await + .map_err(|_| RESTError::Custom("Couldn't find the last epoch when the given pool distributed rewards".to_string()))?; + + Ok(rweb::Json::from(json!(pool_last_reward_earned_epoch))) +} + #[get("/pool/declared_pledge/{pool_hash}")] #[openapi( diff --git a/src/server/handler/handler_rest/mod.rs b/src/server/handler/handler_rest/mod.rs index 2840bd0..b9bf33e 100644 --- a/src/server/handler/handler_rest/mod.rs +++ b/src/server/handler/handler_rest/mod.rs @@ -5,9 +5,10 @@ use info::{ address_exists, handle_asset_for_stake_address, handle_get_asset_for_addresses, is_nft, mint_metadata, retrieve_active_pools, token_supply, tx_history, tx_history_discover, utxos_per_addr, retrieve_staked_amount, retrieve_generated_rewards, pool_vrf_key_hash, - pool_blocks_minted, pool_blocks_current_epoch, pool_declared_pledge, pool_margin_cost, - pool_fixed_cost, pool_reward_address, pool_owner, pool_registration, pool_retirement, - pool_url, pool_ticker, pool_metadata_json, pool_name, pool_homepage, pool_description, + pool_blocks_minted, pool_blocks_current_epoch, pool_reward_recipients, pool_last_reward_earned_epoch, + pool_declared_pledge, pool_margin_cost, pool_fixed_cost, pool_reward_address, pool_owner, + pool_registration, pool_retirement, pool_url, pool_ticker, pool_metadata_json, pool_name, + pool_homepage, pool_description, }; use rweb::*; @@ -30,6 +31,8 @@ use rweb::*; pool_vrf_key_hash, pool_blocks_minted, pool_blocks_current_epoch, + pool_reward_recipients, + pool_last_reward_earned_epoch, pool_declared_pledge, pool_margin_cost, pool_fixed_cost, From b34eb3cd62ba6f675e6f426b9c725639290c4438 Mon Sep 17 00:00:00 2001 From: Amir Abdin Date: Fri, 13 Oct 2023 14:01:10 +0200 Subject: [PATCH 08/12] Add endpoint for all pages --- src/server/handler/handler_rest/info.rs | 21 +++++++++++++++++++-- src/server/handler/handler_rest/mod.rs | 5 +++-- 2 files changed, 22 insertions(+), 4 deletions(-) diff --git a/src/server/handler/handler_rest/info.rs b/src/server/handler/handler_rest/info.rs index fd84b86..afd31aa 100644 --- a/src/server/handler/handler_rest/info.rs +++ b/src/server/handler/handler_rest/info.rs @@ -395,9 +395,9 @@ pub async fn handle_asset_for_stake_address( #[get("/pools/{page}")] #[openapi( - id = "api.info.pools", + id = "api.info.pools_one_page", tags("Stake Pool"), - summary = "Get Stake Pool List" + summary = "Get Stake Pool List (specified page)" )] pub async fn retrieve_active_pools( page: usize, @@ -418,6 +418,23 @@ pub async fn retrieve_active_pools( Ok(rweb::Json::from(json!(pools_paged[page]))) } +#[get("/pools/pages")] +#[openapi( + id = "api.info.pools_all_pages", + tags("Stake Pool"), + summary = "Get Stake Pool List (all pages)" +)] +pub async fn retrieve_active_pools_all_pages( + #[filter = "with_auth"] _user_id: String, +) -> Result, Rejection> { + let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { + db_path: std::env::var("DBSYNC_URL").unwrap(), + })); + let pools = crate::dbsync::get_pools(dp.provider()).await.unwrap(); + let pools_paged: Vec> = pools.chunks(100).map(|s| s.into()).collect(); + Ok(rweb::Json::from(json!(pools_paged))) +} + #[get("/tokens/supply/{fingerprint}")] #[openapi( id = "api.info.tokens.supply", diff --git a/src/server/handler/handler_rest/mod.rs b/src/server/handler/handler_rest/mod.rs index b9bf33e..53fc477 100644 --- a/src/server/handler/handler_rest/mod.rs +++ b/src/server/handler/handler_rest/mod.rs @@ -3,8 +3,8 @@ pub(crate) mod info; use info::{ address_exists, handle_asset_for_stake_address, handle_get_asset_for_addresses, is_nft, - mint_metadata, retrieve_active_pools, token_supply, tx_history, tx_history_discover, - utxos_per_addr, retrieve_staked_amount, retrieve_generated_rewards, pool_vrf_key_hash, + mint_metadata, retrieve_active_pools, retrieve_active_pools_all_pages, token_supply, tx_history, + tx_history_discover, utxos_per_addr, retrieve_staked_amount, retrieve_generated_rewards, pool_vrf_key_hash, pool_blocks_minted, pool_blocks_current_epoch, pool_reward_recipients, pool_last_reward_earned_epoch, pool_declared_pledge, pool_margin_cost, pool_fixed_cost, pool_reward_address, pool_owner, pool_registration, pool_retirement, pool_url, pool_ticker, pool_metadata_json, pool_name, @@ -25,6 +25,7 @@ use rweb::*; handle_asset_for_stake_address, handle_get_asset_for_addresses, retrieve_active_pools, + retrieve_active_pools_all_pages, is_nft, retrieve_staked_amount, retrieve_generated_rewards, From 37d7d26067fe58cb3ce8c2137bca43e424bd48e5 Mon Sep 17 00:00:00 2001 From: Amir Abdin Date: Fri, 13 Oct 2023 15:56:16 +0200 Subject: [PATCH 09/12] improve error handling --- src/dbsync/error.rs | 2 + src/provider/error.rs | 2 + src/server/error.rs | 2 +- src/server/handler/handler_rest/info.rs | 86 ++++++++++++------------- 4 files changed, 48 insertions(+), 44 deletions(-) diff --git a/src/dbsync/error.rs b/src/dbsync/error.rs index 4aaf143..570696e 100644 --- a/src/dbsync/error.rs +++ b/src/dbsync/error.rs @@ -44,3 +44,5 @@ impl From for DataProviderDB DataProviderDBSyncError::Custom(err.to_string()) } } + +impl rweb::reject::Reject for DataProviderDBSyncError {} \ No newline at end of file diff --git a/src/provider/error.rs b/src/provider/error.rs index 1c5994a..1fb29f3 100644 --- a/src/provider/error.rs +++ b/src/provider/error.rs @@ -40,3 +40,5 @@ impl From for DataProviderError { DataProviderError::Custom(err.to_string()) } } + +impl rweb::reject::Reject for DataProviderError {} \ No newline at end of file diff --git a/src/server/error.rs b/src/server/error.rs index cc27439..b22c978 100644 --- a/src/server/error.rs +++ b/src/server/error.rs @@ -1,5 +1,5 @@ use rweb::warp::{http::StatusCode, Rejection, Reply}; -use std::convert::Infallible; +use std::{convert::Infallible, env::VarError}; use thiserror::Error; use super::models::ErrorResponse; diff --git a/src/server/handler/handler_rest/info.rs b/src/server/handler/handler_rest/info.rs index afd31aa..5eb5d5c 100644 --- a/src/server/handler/handler_rest/info.rs +++ b/src/server/handler/handler_rest/info.rs @@ -24,7 +24,7 @@ pub async fn utxos_per_addr( ) -> Result, Rejection> { // check against dataprovider let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); let utxos = dp @@ -48,12 +48,12 @@ pub async fn address_exists( #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); - let mut addresses: Vec = parse_string_vec_from_query(&addresses).unwrap(); + let mut addresses: Vec = parse_string_vec_from_query(&addresses)?; let addresses = addresses.iter_mut().map(|address| &address[..]).collect(); - let result = dp.addresses_exist(&addresses).await.unwrap(); + let result = dp.addresses_exist(&addresses).await?; Ok(rweb::Json::from(json!(result))) } @@ -84,7 +84,7 @@ pub async fn mint_metadata( #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_URL").unwrap(), + db_path: dotenv::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); let metadata: TokenInfoView = match dp.mint_metadata(&fingerprint).await { Ok(metadata) => metadata, @@ -105,10 +105,10 @@ pub async fn mint_metadata_policy_assetname( #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); let fingerprint = make_fingerprint(&policy, &assetname).unwrap(); - let metadata: TokenInfoView = dp.mint_metadata(&fingerprint).await.unwrap(); + let metadata: TokenInfoView = dp.mint_metadata(&fingerprint).await?; Ok(rweb::Json::from(json!(metadata))) } @@ -124,14 +124,14 @@ pub async fn tx_history( #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); - let mut addresses: Vec = parse_string_vec_from_query(&addresses).unwrap(); + let mut addresses: Vec = parse_string_vec_from_query(&addresses)?; let addresses = addresses.iter_mut().map(|address| &address[..]).collect(); let slot = slot.parse::().ok(); - let history = dp.tx_history(&addresses, slot).await.unwrap(); + let history = dp.tx_history(&addresses, slot).await?; Ok(rweb::Json::from(json!(history))) } @@ -147,7 +147,7 @@ pub async fn tx_history_discover( #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); debug!("Try to discover Transaction: {:?}", hash); let tx = crate::dbsync::discover_transaction(dp.provider(), &hash).await; @@ -190,13 +190,13 @@ pub(crate) async fn get_asset_for_addresses( ) -> Result, Rejection> { debug!("{addresses:?}"); let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); let mut utxos = TransactionUnspentOutputs::new(); for a in addresses { - let us = dp.script_utxos(a).await.unwrap(); + let us = dp.script_utxos(a).await?; utxos.merge(us); } @@ -219,7 +219,7 @@ pub(crate) async fn get_asset_for_addresses( let k = assets.keys(); for a in 0..k.len() { let asset = k.get(a); - let amt = assets.get(&asset).unwrap(); + let amt = assets.get(&asset).unwrap(); let fingerprint = make_fingerprint(&policy.to_hex(), &hex::encode(asset.name())).unwrap(); // Deactivated Metadata Requests for performance @@ -303,7 +303,7 @@ pub async fn handle_asset_for_stake_address( }; let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); // dp //.wallet_utxos(&reward_address.to_bech32(None).unwrap()) @@ -404,9 +404,9 @@ pub async fn retrieve_active_pools( #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); - let pools = crate::dbsync::get_pools(dp.provider()).await.unwrap(); + let pools = crate::dbsync::get_pools(dp.provider()).await?; let pools_paged: Vec> = pools.chunks(100).map(|s| s.into()).collect(); if pools_paged.len() < page { return make_error( @@ -428,9 +428,9 @@ pub async fn retrieve_active_pools_all_pages( #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); - let pools = crate::dbsync::get_pools(dp.provider()).await.unwrap(); + let pools = crate::dbsync::get_pools(dp.provider()).await?; let pools_paged: Vec> = pools.chunks(100).map(|s| s.into()).collect(); Ok(rweb::Json::from(json!(pools_paged))) } @@ -446,7 +446,7 @@ pub async fn token_supply( #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); let supply = crate::dbsync::token_supply(dp.provider(), &fingerprint).await; if let Err(e) = &supply { @@ -456,7 +456,7 @@ pub async fn token_supply( None, ); } - Ok(rweb::Json::from(json!(supply.unwrap()))) + Ok(rweb::Json::from(json!(supply?))) } #[get("/tokens/isNft/")] @@ -481,7 +481,7 @@ pub async fn is_nft( }; debug!("Creatign dataprovider instance"); let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); debug!("Try to execute query"); let supply = crate::dbsync::is_nft( @@ -497,7 +497,7 @@ pub async fn is_nft( None, ); } - Ok(rweb::Json::from(json!(supply.unwrap()))) + Ok(rweb::Json::from(json!(supply?))) } #[get("/epoch/stake/amount/{stake_addr}/{epoch}")] @@ -512,7 +512,7 @@ pub async fn retrieve_staked_amount( #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); dbg!(epoch.clone()); @@ -538,7 +538,7 @@ pub async fn retrieve_generated_rewards( #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); let generated_rewards = dp @@ -560,7 +560,7 @@ pub async fn pool_vrf_key_hash( #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); let pool_vrf_key_hash = dp @@ -582,7 +582,7 @@ pub async fn pool_blocks_minted( #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); let pool_blocks_minted = dp @@ -604,7 +604,7 @@ pub async fn pool_blocks_current_epoch( #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); let pool_blocks_current_epoch = dp @@ -626,7 +626,7 @@ pub async fn pool_reward_recipients( #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); let pool_reward_recipients = dp @@ -648,7 +648,7 @@ pub async fn pool_last_reward_earned_epoch( #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); let pool_last_reward_earned_epoch = dp @@ -671,7 +671,7 @@ pub async fn pool_declared_pledge( #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); let pool_declared_pledge = dp @@ -693,7 +693,7 @@ pub async fn pool_margin_cost( #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); let pool_margin_cost = dp @@ -715,7 +715,7 @@ pub async fn pool_fixed_cost( #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); let pool_fixed_cost = dp @@ -737,7 +737,7 @@ pub async fn pool_reward_address( #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); let pool_reward_address = dp @@ -759,7 +759,7 @@ pub async fn pool_owner( #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); let pool_owner = dp @@ -781,7 +781,7 @@ pub async fn pool_registration( #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); let pool_registration = dp @@ -803,7 +803,7 @@ pub async fn pool_retirement( #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); let pool_retirement = dp @@ -825,7 +825,7 @@ pub async fn pool_url( #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); let pool_url = dp @@ -847,7 +847,7 @@ pub async fn pool_ticker( #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); let pool_ticker = dp @@ -869,7 +869,7 @@ pub async fn pool_metadata_json( #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); let pool_metadata_json = dp @@ -891,7 +891,7 @@ pub async fn pool_name( #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); let pool_name = dp @@ -913,7 +913,7 @@ pub async fn pool_homepage( #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); let pool_homepage = dp @@ -935,7 +935,7 @@ pub async fn pool_description( #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").unwrap(), + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, })); let pool_description = dp From b5fc0fe2559a0f67acb73c9c64f579f69cec0621 Mon Sep 17 00:00:00 2001 From: Amir Abdin Date: Fri, 13 Oct 2023 16:01:17 +0200 Subject: [PATCH 10/12] Remove enum from type name --- src/dbsync/models.rs | 3 ++- src/dbsync/schema.rs | 7 ++++--- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/src/dbsync/models.rs b/src/dbsync/models.rs index 76e3d33..f96a475 100644 --- a/src/dbsync/models.rs +++ b/src/dbsync/models.rs @@ -35,8 +35,9 @@ pub enum Scriptpurposetype { Reward, } +/// Represents SQL enum #[derive(Clone, Copy, Debug, DbEnum, PartialEq, Eq)] // Debug, Clone, QueryId -#[ExistingTypePath = "crate::dbsync::schema::sql_types::RewardTypeEnum"] +#[ExistingTypePath = "crate::dbsync::schema::sql_types::RewardType"] pub enum RewardType { #[db_rename = "leader"] Leader, diff --git a/src/dbsync/schema.rs b/src/dbsync/schema.rs index 73eb6fb..dad5781 100644 --- a/src/dbsync/schema.rs +++ b/src/dbsync/schema.rs @@ -14,9 +14,10 @@ pub mod sql_types { #[diesel(postgres_type(name = "Scriptpurposetype"))] pub struct Scriptpurposetype; + /// Represents SQL enum #[derive(SqlType, QueryId)] #[diesel(postgres_type(name = "rewardtype"))] - pub struct RewardTypeEnum; + pub struct RewardType; #[derive(SqlType, QueryId)] #[diesel(postgres_type(name = "Scripttype"))] @@ -477,13 +478,13 @@ table! { table! { use diesel::sql_types::*; - use super::sql_types::RewardTypeEnum; + use super::sql_types::RewardType; reward (id) { id -> Int8, addr_id -> Int8, #[sql_name = "type"] - type_ -> RewardTypeEnum, + type_ -> RewardType, amount -> Numeric, earned_epoch -> Int8, spendable_epoch -> Int8, From 7a144ac2d2ad1893479a120cf50f86fa52b6cd9e Mon Sep 17 00:00:00 2001 From: Amir Abdin Date: Fri, 13 Oct 2023 16:04:14 +0200 Subject: [PATCH 11/12] Clean up the unit tests --- src/dbsync/api.rs | 36 ------------------------------------ 1 file changed, 36 deletions(-) diff --git a/src/dbsync/api.rs b/src/dbsync/api.rs index e5309e4..15f2919 100644 --- a/src/dbsync/api.rs +++ b/src/dbsync/api.rs @@ -2498,8 +2498,6 @@ mod tests { let pool_hash = "pool1uh5xdjv70q5eyl5z644p23mvhd3dx0gwr8pjnlj9pwd3jgkvd0e"; let _func_value = hex::encode(super::pool_vrf_key_hash(dp.provider(), pool_hash).await.unwrap()); let _manual_value = "335399acf3228243efb0fec0e43f18d61a496d4fd740fd800f9b91b5fa7d0540"; - - // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2510,8 +2508,6 @@ mod tests { let pool_hash = "pool1uh5xdjv70q5eyl5z644p23mvhd3dx0gwr8pjnlj9pwd3jgkvd0e"; let _func_value = super::pool_blocks_minted(dp.provider(), pool_hash).await.unwrap(); let _manual_value = 13; - - // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2522,8 +2518,6 @@ mod tests { let pool_hash = "pool14u22dyym8k2g2twvgct86njg3m9cc7j2fc74yamy6672s6up7a0"; let _func_value = super::pool_blocks_current_epoch(dp.provider(), pool_hash).await.unwrap(); let _manual_value = 25; - - // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2534,8 +2528,6 @@ mod tests { let pool_hash = "pool1rk2y9gx6vll8lawzdqlky5p2a3ypzsxg07arg8gmhkjj2905035"; let _func_value = super::pool_reward_recipients(dp.provider(), pool_hash).await.unwrap(); let _manual_value = 207; - - // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2546,8 +2538,6 @@ mod tests { let pool_hash = "pool1rk2y9gx6vll8lawzdqlky5p2a3ypzsxg07arg8gmhkjj2905035"; let _func_value = super::pool_last_reward_earned_epoch(dp.provider(), pool_hash).await.unwrap(); let _manual_value = 349; - - // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2558,8 +2548,6 @@ mod tests { let pool_hash = "pool1vezalga3ge0mt0xf4txz66ctufk6nrmemhhpshwkhedk5jf0stw"; let _func_value = super::pool_declared_pledge(dp.provider(), pool_hash).await.unwrap(); let _manual_value = BigDecimal::from_str("125000000000").unwrap(); - - // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2570,8 +2558,6 @@ mod tests { let pool_hash = "pool1vezalga3ge0mt0xf4txz66ctufk6nrmemhhpshwkhedk5jf0stw"; let _func_value = super::pool_margin_cost(dp.provider(), pool_hash).await.unwrap(); let _manual_value = 0.075; - - // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2582,8 +2568,6 @@ mod tests { let pool_hash = "pool1vezalga3ge0mt0xf4txz66ctufk6nrmemhhpshwkhedk5jf0stw"; let _func_value = super::pool_fixed_cost(dp.provider(), pool_hash).await.unwrap(); let _manual_value = BigDecimal::from_str("340000000").unwrap(); - - // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2594,8 +2578,6 @@ mod tests { let pool_hash = "pool1vezalga3ge0mt0xf4txz66ctufk6nrmemhhpshwkhedk5jf0stw"; let _func_value = super::pool_reward_address(dp.provider(), pool_hash).await.unwrap(); let _manual_value = "stake_test1uz5ah77y8xvnxs6cyp979hg7fhxezjw39jfrpardqymnz7sg7ea8y"; - - // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2606,8 +2588,6 @@ mod tests { let pool_hash = "pool1vezalga3ge0mt0xf4txz66ctufk6nrmemhhpshwkhedk5jf0stw"; let _func_value = super::pool_owner(dp.provider(), pool_hash).await.unwrap(); let _manual_value = "stake_test1uz5ah77y8xvnxs6cyp979hg7fhxezjw39jfrpardqymnz7sg7ea8y"; - - // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2618,8 +2598,6 @@ mod tests { let pool_hash = "pool1vezalga3ge0mt0xf4txz66ctufk6nrmemhhpshwkhedk5jf0stw"; let _func_value = super::pool_registration(dp.provider(), pool_hash).await.unwrap(); let _manual_value = 175; - - // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2630,8 +2608,6 @@ mod tests { let pool_hash = "pool17hsjytkcntlh6py4gnmk4695cux28tpcxrggs9ln97mvvtplr2m"; let func_value = super::pool_retirement(dp.provider(), pool_hash).await.unwrap(); let manual_value = 26; - - assert_eq!(func_value, manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2642,8 +2618,6 @@ mod tests { let pool_hash = "pool17hsjytkcntlh6py4gnmk4695cux28tpcxrggs9ln97mvvtplr2m"; let _func_value = super::pool_url(dp.provider(), pool_hash).await.unwrap(); let _manual_value = "https://armadacardano.io/metadata.json"; - - // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2654,8 +2628,6 @@ mod tests { let pool_hash = "pool1l5u4zh84na80xr56d342d32rsdw62qycwaw97hy9wwsc6axdwla"; let _func_value = super::pool_ticker(dp.provider(), pool_hash).await.unwrap(); let _manual_value = "EUSKL"; - - // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2666,8 +2638,6 @@ mod tests { let pool_hash = "pool1l5u4zh84na80xr56d342d32rsdw62qycwaw97hy9wwsc6axdwla"; let _func_value = super::pool_metadata_json(dp.provider(), pool_hash).await.unwrap(); let _manual_value = json!({"name": "EUSKAL STAKE POOL TESTNET", "ticker": "EUSKL", "homepage": "https://euskalstakepool.win", "description": "EUSKAL STAKE POOL TESTNET"}); - - // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2678,8 +2648,6 @@ mod tests { let pool_hash = "pool1l5u4zh84na80xr56d342d32rsdw62qycwaw97hy9wwsc6axdwla"; let _func_value = super::pool_name(dp.provider(), pool_hash).await.unwrap(); let _manual_value = "EUSKAL STAKE POOL TESTNET"; - - // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2690,8 +2658,6 @@ mod tests { let pool_hash = "pool1l5u4zh84na80xr56d342d32rsdw62qycwaw97hy9wwsc6axdwla"; let _func_value = super::pool_homepage(dp.provider(), pool_hash).await.unwrap(); let _manual_value = "https://euskalstakepool.win"; - - // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } #[tokio::test] @@ -2702,7 +2668,5 @@ mod tests { let pool_hash = "pool1l5u4zh84na80xr56d342d32rsdw62qycwaw97hy9wwsc6axdwla"; let _func_value = super::pool_description(dp.provider(), pool_hash).await.unwrap(); let _manual_value = "EUSKAL STAKE POOL TESTNET"; - - // assert_eq!(_func_value, _manual_value); // The value might change in the future. But it passed at the time of this writing. } } \ No newline at end of file From f33f7c2111eacb9f5c08f92ebfc90ed33274bd7f Mon Sep 17 00:00:00 2001 From: Amir Abdin Date: Fri, 10 Nov 2023 14:47:56 +0100 Subject: [PATCH 12/12] refactor --- src/dbsync/api.rs | 175 ++++++--------------- src/server/handler/handler_rest/info.rs | 197 ++++++------------------ 2 files changed, 90 insertions(+), 282 deletions(-) diff --git a/src/dbsync/api.rs b/src/dbsync/api.rs index 15f2919..41284eb 100644 --- a/src/dbsync/api.rs +++ b/src/dbsync/api.rs @@ -2147,30 +2147,32 @@ pub async fn pool_description( #[cfg(test)] mod tests { - use crate::{dbsync::DataProviderDBSyncError, provider::CardanoDataProvider}; + use crate::{dbsync::DataProviderDBSyncError, provider::CardanoDataProvider, DataProvider, DBSyncProvider}; + use crate::dbsync; use bigdecimal::BigDecimal; use itertools::Itertools; use serde_json::json; use std::str::FromStr; + fn data_provider() -> DataProvider { + let dp = DataProvider::new(DBSyncProvider::new(crate::Config { + db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), + })); + dp + } + #[tokio::test] async fn test_tx_history() { let r = vec!["addr_test1qqt86eq9972q3qttj6ztje97llasktzfzvhmdccqjlqjaq2cer3t74yn0dm8xqnr7rtwhkqcrpsmphwcf0mlmn39ry6qy6q5t2","addr_test1qpg8ehvgj9zxrx59et72yjn2p02xwsm3l89jwj8ujcj63ujcer3t74yn0dm8xqnr7rtwhkqcrpsmphwcf0mlmn39ry6qw23emu","addr_test1qqdp3cry5vc2gfjljctdu638tvkcqfx40fjunht9hrmru5zcer3t74yn0dm8xqnr7rtwhkqcrpsmphwcf0mlmn39ry6qnaxxgs","addr_test1qr2mw080ujz0unmpn9lx5ftfuewc6htyr6v3a0svul2zgezcer3t74yn0dm8xqnr7rtwhkqcrpsmphwcf0mlmn39ry6qgryf7t","addr_test1qr7tqh7tsg4lut3jv6tsfwlv464m6knjjw90ugyz8uzgr6zcer3t74yn0dm8xqnr7rtwhkqcrpsmphwcf0mlmn39ry6qt0jxzj","addr_test1qrscurjp292sxv24sepj7ghq4ydkkekzaz53zwfswcna6ljcer3t74yn0dm8xqnr7rtwhkqcrpsmphwcf0mlmn39ry6q8pu3l5","addr_test1qqssrphse6qmp9h0ksu5vfmsx99tfl2lc6rhvy2spd5wr86cer3t74yn0dm8xqnr7rtwhkqcrpsmphwcf0mlmn39ry6qw59j4j","addr_test1qqgagc0fy6nm0qe4h8zqxsg952tqjeg7l7j0agd0cx4u25zcer3t74yn0dm8xqnr7rtwhkqcrpsmphwcf0mlmn39ry6qxvept2"]; - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), - })); - let t = dp.tx_history(&r, None).await.unwrap(); + let t = data_provider().tx_history(&r, None).await.unwrap(); println!("{t:?}"); } #[tokio::test] async fn test_discover_transaction() { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), - })); - let t = crate::dbsync::discover_transaction( - dp.provider(), + let t = dbsync::discover_transaction( + data_provider().provider(), "1b07f1152e52ce0a9dbb561aa2e2d1750ca3a1a4141150a8bad342947a66a3a6", ) .await; @@ -2179,19 +2181,13 @@ mod tests { #[tokio::test] async fn test_get_pools() { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), - })); - let t = crate::dbsync::get_pools(dp.provider()).await; + let t = dbsync::get_pools(data_provider().provider()).await; println!("{t:?}"); } #[tokio::test] async fn test_epoch_nonce() { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), - })); - let t = crate::dbsync::epoch_nonce(dp.provider(), 205) + let t = dbsync::epoch_nonce(data_provider().provider(), 205) .await .unwrap(); println!("Nonce: {}\nEntropy: {:?}", hex::encode(&t.0), t.1); @@ -2199,11 +2195,8 @@ mod tests { #[tokio::test] async fn test_is_nft() { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), - })); - let t = crate::dbsync::is_nft( - dp.provider(), + let t = dbsync::is_nft( + data_provider().provider(), &[ "asset1a0q0grruzd3dm2c9ev890zfaytty8tfcl4qt3a", "asset1h3pg9m9arlwl4l8z3dwg3lwg54j70zqdrjhy88", @@ -2218,11 +2211,8 @@ mod tests { #[tokio::test] async fn test_supply() { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), - })); - let t = crate::dbsync::token_supply( - dp.provider(), + let t = dbsync::token_supply( + data_provider().provider(), "asset1m099azmatp3f3xehsu4sqvr45jzqafxmm0dra0", ) .await @@ -2235,23 +2225,19 @@ mod tests { // make projection accurate for higher epoch values. #[tokio::test] async fn reward_projection() { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), - })); - let pool_hash = "pool1ayc7a29ray6yv4hn7ge72hpjafg9vvpmtscnq9v8r0zh7azas9c"; let stake_addr = "stake_test1upvv3c4l2jfhkannqf3lp4htmqvpscdsmhvyhalaecj3jdqtfcgvh"; // stake_test1upvv3c4l2jfhkannqf3lp4htmqvpscdsmhvyhalaecj3jdqtfcgvh let current_epoch = 25; let func_value = super::personal_delegator_rewards_next_epoch( - dp.provider(), + data_provider().provider(), pool_hash, current_epoch, stake_addr, ) .unwrap(); let real_value = - super::earned_reward(dp.provider(), stake_addr, current_epoch as i64).unwrap(); + super::earned_reward(data_provider().provider(), stake_addr, current_epoch as i64).unwrap(); println!("correct_reward: {}", real_value); println!("projected reward: {}", func_value); @@ -2260,13 +2246,10 @@ mod tests { #[tokio::test] async fn retrieve_staked_amount() { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), - })); let epoch = 275; let stake_addr = "stake_test1upvv3c4l2jfhkannqf3lp4htmqvpscdsmhvyhalaecj3jdqtfcgvh"; - let func_value = super::retrieve_staked_amount(dp.provider(), epoch, stake_addr).unwrap(); + let func_value = super::retrieve_staked_amount(data_provider().provider(), epoch, stake_addr).unwrap(); let real_value = BigDecimal::from_str("10305915710").unwrap(); assert_eq!(func_value, real_value); @@ -2274,11 +2257,8 @@ mod tests { #[tokio::test] async fn mint_metadata() { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), - })); let fingerprint_in = "asset1kngmwlxpfzc6pk027zvhsfpprp452gt3enhhxh"; - let func_value = super::mint_metadata(dp.provider(), fingerprint_in).unwrap(); + let func_value = super::mint_metadata(data_provider().provider(), fingerprint_in).unwrap(); let real_value = super::TokenInfoView { fingerprint: "asset1kngmwlxpfzc6pk027zvhsfpprp452gt3enhhxh".to_string(), policy: "994cf4c18f5613ca49c275f63d464b6d95123bfa8985e82b24b5680b".to_string(), @@ -2306,11 +2286,8 @@ mod tests { #[tokio::test] #[allow(non_snake_case)] async fn mint_metadata_bug_CMW_78() { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), - })); let fingerprint_in = "asset162kdtwq54e5khz5y6naa55xqvk0zk5fpce8c76"; // contains non-UTF8 characters - let func_value = super::mint_metadata(dp.provider(), fingerprint_in).unwrap(); + let func_value = super::mint_metadata(data_provider().provider(), fingerprint_in).unwrap(); let real_value = super::TokenInfoView { fingerprint: "asset162kdtwq54e5khz5y6naa55xqvk0zk5fpce8c76".to_string(), policy: "8cbe56131657c928cee716677bd3eac885f9fcad10f9fa70e533f635".to_string(), @@ -2336,12 +2313,8 @@ mod tests { #[tokio::test] #[allow(non_snake_case)] async fn get_txo_tokens_CMW_81() { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), - })); - let utxo_tokens = super::get_txo_tokens( - dp.provider(), + data_provider().provider(), 3312750, 0 ).unwrap(); @@ -2356,7 +2329,7 @@ mod tests { println!("utxo_tokens[0]: {:?}", utxo_tokens[0]); let utxo_tokens = super::get_txo_tokens( - dp.provider(), + data_provider().provider(), 3312750, 1 ).unwrap(); @@ -2437,12 +2410,8 @@ mod tests { #[tokio::test] #[allow(non_snake_case)] async fn get_utxo_tokens_CMW_81() { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), - })); - let utxo_tokens = super::get_utxo_tokens( - dp.provider(), + data_provider().provider(), 3317731, 0 ).unwrap(); @@ -2466,7 +2435,7 @@ mod tests { assert_eq!(hex::encode(utxo_tokens[2].name.clone()), "7441726b"); let utxo_tokens = super::get_utxo_tokens( - dp.provider(), + data_provider().provider(), 3317731, 1 ).unwrap(); @@ -2492,181 +2461,127 @@ mod tests { #[tokio::test] async fn pool_vrf_key_hash() { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), - })); let pool_hash = "pool1uh5xdjv70q5eyl5z644p23mvhd3dx0gwr8pjnlj9pwd3jgkvd0e"; - let _func_value = hex::encode(super::pool_vrf_key_hash(dp.provider(), pool_hash).await.unwrap()); + let _func_value = hex::encode(super::pool_vrf_key_hash(data_provider().provider(), pool_hash).await.unwrap()); let _manual_value = "335399acf3228243efb0fec0e43f18d61a496d4fd740fd800f9b91b5fa7d0540"; } #[tokio::test] async fn pool_blocks_minted() { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), - })); let pool_hash = "pool1uh5xdjv70q5eyl5z644p23mvhd3dx0gwr8pjnlj9pwd3jgkvd0e"; - let _func_value = super::pool_blocks_minted(dp.provider(), pool_hash).await.unwrap(); + let _func_value = super::pool_blocks_minted(data_provider().provider(), pool_hash).await.unwrap(); let _manual_value = 13; } #[tokio::test] async fn pool_blocks_current_epoch() { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), - })); let pool_hash = "pool14u22dyym8k2g2twvgct86njg3m9cc7j2fc74yamy6672s6up7a0"; - let _func_value = super::pool_blocks_current_epoch(dp.provider(), pool_hash).await.unwrap(); + let _func_value = super::pool_blocks_current_epoch(data_provider().provider(), pool_hash).await.unwrap(); let _manual_value = 25; } #[tokio::test] async fn pool_reward_recipients() { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), - })); let pool_hash = "pool1rk2y9gx6vll8lawzdqlky5p2a3ypzsxg07arg8gmhkjj2905035"; - let _func_value = super::pool_reward_recipients(dp.provider(), pool_hash).await.unwrap(); + let _func_value = super::pool_reward_recipients(data_provider().provider(), pool_hash).await.unwrap(); let _manual_value = 207; } #[tokio::test] async fn pool_last_reward_earned_epoch() { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), - })); let pool_hash = "pool1rk2y9gx6vll8lawzdqlky5p2a3ypzsxg07arg8gmhkjj2905035"; - let _func_value = super::pool_last_reward_earned_epoch(dp.provider(), pool_hash).await.unwrap(); + let _func_value = super::pool_last_reward_earned_epoch(data_provider().provider(), pool_hash).await.unwrap(); let _manual_value = 349; } #[tokio::test] async fn pool_declared_pledge() { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), - })); let pool_hash = "pool1vezalga3ge0mt0xf4txz66ctufk6nrmemhhpshwkhedk5jf0stw"; - let _func_value = super::pool_declared_pledge(dp.provider(), pool_hash).await.unwrap(); + let _func_value = super::pool_declared_pledge(data_provider().provider(), pool_hash).await.unwrap(); let _manual_value = BigDecimal::from_str("125000000000").unwrap(); } #[tokio::test] async fn pool_margin_cost() { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), - })); let pool_hash = "pool1vezalga3ge0mt0xf4txz66ctufk6nrmemhhpshwkhedk5jf0stw"; - let _func_value = super::pool_margin_cost(dp.provider(), pool_hash).await.unwrap(); + let _func_value = super::pool_margin_cost(data_provider().provider(), pool_hash).await.unwrap(); let _manual_value = 0.075; } #[tokio::test] async fn pool_fixed_cost() { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), - })); let pool_hash = "pool1vezalga3ge0mt0xf4txz66ctufk6nrmemhhpshwkhedk5jf0stw"; - let _func_value = super::pool_fixed_cost(dp.provider(), pool_hash).await.unwrap(); + let _func_value = super::pool_fixed_cost(data_provider().provider(), pool_hash).await.unwrap(); let _manual_value = BigDecimal::from_str("340000000").unwrap(); } #[tokio::test] async fn pool_reward_address() { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), - })); let pool_hash = "pool1vezalga3ge0mt0xf4txz66ctufk6nrmemhhpshwkhedk5jf0stw"; - let _func_value = super::pool_reward_address(dp.provider(), pool_hash).await.unwrap(); + let _func_value = super::pool_reward_address(data_provider().provider(), pool_hash).await.unwrap(); let _manual_value = "stake_test1uz5ah77y8xvnxs6cyp979hg7fhxezjw39jfrpardqymnz7sg7ea8y"; } #[tokio::test] async fn pool_owner() { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), - })); let pool_hash = "pool1vezalga3ge0mt0xf4txz66ctufk6nrmemhhpshwkhedk5jf0stw"; - let _func_value = super::pool_owner(dp.provider(), pool_hash).await.unwrap(); + let _func_value = super::pool_owner(data_provider().provider(), pool_hash).await.unwrap(); let _manual_value = "stake_test1uz5ah77y8xvnxs6cyp979hg7fhxezjw39jfrpardqymnz7sg7ea8y"; } #[tokio::test] async fn pool_registration() { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), - })); let pool_hash = "pool1vezalga3ge0mt0xf4txz66ctufk6nrmemhhpshwkhedk5jf0stw"; - let _func_value = super::pool_registration(dp.provider(), pool_hash).await.unwrap(); + let _func_value = super::pool_registration(data_provider().provider(), pool_hash).await.unwrap(); let _manual_value = 175; } #[tokio::test] async fn pool_retirement() { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), - })); let pool_hash = "pool17hsjytkcntlh6py4gnmk4695cux28tpcxrggs9ln97mvvtplr2m"; - let func_value = super::pool_retirement(dp.provider(), pool_hash).await.unwrap(); + let func_value = super::pool_retirement(data_provider().provider(), pool_hash).await.unwrap(); let manual_value = 26; } #[tokio::test] async fn pool_url() { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), - })); let pool_hash = "pool17hsjytkcntlh6py4gnmk4695cux28tpcxrggs9ln97mvvtplr2m"; - let _func_value = super::pool_url(dp.provider(), pool_hash).await.unwrap(); + let _func_value = super::pool_url(data_provider().provider(), pool_hash).await.unwrap(); let _manual_value = "https://armadacardano.io/metadata.json"; } #[tokio::test] async fn pool_ticker() { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), - })); let pool_hash = "pool1l5u4zh84na80xr56d342d32rsdw62qycwaw97hy9wwsc6axdwla"; - let _func_value = super::pool_ticker(dp.provider(), pool_hash).await.unwrap(); + let _func_value = super::pool_ticker(data_provider().provider(), pool_hash).await.unwrap(); let _manual_value = "EUSKL"; } #[tokio::test] async fn pool_metadata_json() { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), - })); let pool_hash = "pool1l5u4zh84na80xr56d342d32rsdw62qycwaw97hy9wwsc6axdwla"; - let _func_value = super::pool_metadata_json(dp.provider(), pool_hash).await.unwrap(); + let _func_value = super::pool_metadata_json(data_provider().provider(), pool_hash).await.unwrap(); let _manual_value = json!({"name": "EUSKAL STAKE POOL TESTNET", "ticker": "EUSKL", "homepage": "https://euskalstakepool.win", "description": "EUSKAL STAKE POOL TESTNET"}); } #[tokio::test] async fn pool_name() { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), - })); let pool_hash = "pool1l5u4zh84na80xr56d342d32rsdw62qycwaw97hy9wwsc6axdwla"; - let _func_value = super::pool_name(dp.provider(), pool_hash).await.unwrap(); + let _func_value = super::pool_name(data_provider().provider(), pool_hash).await.unwrap(); let _manual_value = "EUSKAL STAKE POOL TESTNET"; } #[tokio::test] async fn pool_homepage() { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), - })); let pool_hash = "pool1l5u4zh84na80xr56d342d32rsdw62qycwaw97hy9wwsc6axdwla"; - let _func_value = super::pool_homepage(dp.provider(), pool_hash).await.unwrap(); + let _func_value = super::pool_homepage(data_provider().provider(), pool_hash).await.unwrap(); let _manual_value = "https://euskalstakepool.win"; } #[tokio::test] async fn pool_description() { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_DB_URL").unwrap(), - })); let pool_hash = "pool1l5u4zh84na80xr56d342d32rsdw62qycwaw97hy9wwsc6axdwla"; - let _func_value = super::pool_description(dp.provider(), pool_hash).await.unwrap(); + let _func_value = super::pool_description(data_provider().provider(), pool_hash).await.unwrap(); let _manual_value = "EUSKAL STAKE POOL TESTNET"; } } \ No newline at end of file diff --git a/src/server/handler/handler_rest/info.rs b/src/server/handler/handler_rest/info.rs index 5eb5d5c..3c32479 100644 --- a/src/server/handler/handler_rest/info.rs +++ b/src/server/handler/handler_rest/info.rs @@ -6,12 +6,22 @@ use crate::server::error::RESTError; use crate::server::filter::with_auth; use crate::server::handler::make_error; use crate::{models::TokenInfoView, provider::CardanoDataProvider}; +use crate::DataProvider; +use crate::DBSyncProvider; use ::log::debug; use cardano_serialization_lib::utils::from_bignum; use dcslc::{make_fingerprint, TransactionUnspentOutputs}; use rweb::*; use serde_json::json; +fn data_provider() -> Result, Rejection> { + let dp = DataProvider::new(DBSyncProvider::new(crate::Config { + db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, + })); + + Ok(dp) +} + #[get("/utxos/{address}")] #[openapi( id = "api.info.utxos", @@ -23,11 +33,7 @@ pub async fn utxos_per_addr( #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { // check against dataprovider - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); - - let utxos = dp + let utxos = data_provider()? .script_utxos(&address) .await .map_err(|_| RESTError::Custom("Could not find UTxOs".to_string()))?; @@ -47,13 +53,10 @@ pub async fn address_exists( #[query] addresses: String, #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); let mut addresses: Vec = parse_string_vec_from_query(&addresses)?; let addresses = addresses.iter_mut().map(|address| &address[..]).collect(); - let result = dp.addresses_exist(&addresses).await?; + let result = data_provider()?.addresses_exist(&addresses).await?; Ok(rweb::Json::from(json!(result))) } @@ -83,10 +86,7 @@ pub async fn mint_metadata( fingerprint: String, #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: dotenv::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); - let metadata: TokenInfoView = match dp.mint_metadata(&fingerprint).await { + let metadata: TokenInfoView = match data_provider()?.mint_metadata(&fingerprint).await { Ok(metadata) => metadata, Err(e) => return Err(RESTError::Custom(e.to_string()).into()), }; @@ -104,11 +104,8 @@ pub async fn mint_metadata_policy_assetname( assetname: String, #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); let fingerprint = make_fingerprint(&policy, &assetname).unwrap(); - let metadata: TokenInfoView = dp.mint_metadata(&fingerprint).await?; + let metadata: TokenInfoView = data_provider()?.mint_metadata(&fingerprint).await?; Ok(rweb::Json::from(json!(metadata))) } @@ -123,15 +120,13 @@ pub async fn tx_history( #[query] slot: String, #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); + let mut addresses: Vec = parse_string_vec_from_query(&addresses)?; let addresses = addresses.iter_mut().map(|address| &address[..]).collect(); let slot = slot.parse::().ok(); - let history = dp.tx_history(&addresses, slot).await?; + let history = data_provider()?.tx_history(&addresses, slot).await?; Ok(rweb::Json::from(json!(history))) } @@ -146,11 +141,10 @@ pub async fn tx_history_discover( hash: String, #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); debug!("Try to discover Transaction: {:?}", hash); - let tx = crate::dbsync::discover_transaction(dp.provider(), &hash).await; + let tx = crate::dbsync::discover_transaction( + data_provider()?.provider(), &hash + ).await; match tx { Ok(tx) => Ok(rweb::Json::from(json!(tx))), @@ -189,14 +183,10 @@ pub(crate) async fn get_asset_for_addresses( addresses: &Vec, ) -> Result, Rejection> { debug!("{addresses:?}"); - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); - let mut utxos = TransactionUnspentOutputs::new(); for a in addresses { - let us = dp.script_utxos(a).await?; + let us = data_provider()?.script_utxos(a).await?; utxos.merge(us); } @@ -302,13 +292,9 @@ pub async fn handle_asset_for_stake_address( } }; - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); - // dp //.wallet_utxos(&reward_address.to_bech32(None).unwrap()) let utxos = match get_stake_address_utxos_dep( - dp.provider(), + data_provider()?.provider(), &reward_address.to_bech32(None).unwrap(), ) { Ok(u) => u, @@ -403,10 +389,7 @@ pub async fn retrieve_active_pools( page: usize, #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); - let pools = crate::dbsync::get_pools(dp.provider()).await?; + let pools = crate::dbsync::get_pools(data_provider()?.provider()).await?; let pools_paged: Vec> = pools.chunks(100).map(|s| s.into()).collect(); if pools_paged.len() < page { return make_error( @@ -427,10 +410,7 @@ pub async fn retrieve_active_pools( pub async fn retrieve_active_pools_all_pages( #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); - let pools = crate::dbsync::get_pools(dp.provider()).await?; + let pools = crate::dbsync::get_pools(data_provider()?.provider()).await?; let pools_paged: Vec> = pools.chunks(100).map(|s| s.into()).collect(); Ok(rweb::Json::from(json!(pools_paged))) } @@ -445,10 +425,7 @@ pub async fn token_supply( fingerprint: String, #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); - let supply = crate::dbsync::token_supply(dp.provider(), &fingerprint).await; + let supply = crate::dbsync::token_supply(data_provider()?.provider(), &fingerprint).await; if let Err(e) = &supply { return make_error( format!("Could not get supply for {:?}", e.to_string()), @@ -479,13 +456,9 @@ pub async fn is_nft( ); } }; - debug!("Creatign dataprovider instance"); - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); debug!("Try to execute query"); let supply = crate::dbsync::is_nft( - dp.provider(), + data_provider()?.provider(), &f.iter().map(|n| &**n).collect::>()[..], ) .await; @@ -511,14 +484,10 @@ pub async fn retrieve_staked_amount( stake_addr: String, #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); - dbg!(epoch.clone()); dbg!(stake_addr.clone()); - let staked_amount = dp + let staked_amount = data_provider()? .retrieve_staked_amount(epoch, &stake_addr) .await .map_err(|_| RESTError::Custom("Couldn't find staked amount".to_string()))?; @@ -537,11 +506,7 @@ pub async fn retrieve_generated_rewards( stake_addr: String, #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); - - let generated_rewards = dp + let generated_rewards = data_provider()? .retrieve_generated_rewards(&stake_addr) .await .map_err(|_| RESTError::Custom("Couldn't find generated rewards".to_string()))?; @@ -559,11 +524,7 @@ pub async fn pool_vrf_key_hash( pool_hash: String, #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); - - let pool_vrf_key_hash = dp + let pool_vrf_key_hash = data_provider()? .pool_vrf_key_hash(&pool_hash) .await .map_err(|_| RESTError::Custom("Couldn't find pools VRF key hash".to_string()))?; @@ -581,11 +542,7 @@ pub async fn pool_blocks_minted( pool_hash: String, #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); - - let pool_blocks_minted = dp + let pool_blocks_minted = data_provider()? .pool_blocks_minted(&pool_hash) .await .map_err(|_| RESTError::Custom("Couldn't find the total number of blocks minted by the given pool".to_string()))?; @@ -603,11 +560,7 @@ pub async fn pool_blocks_current_epoch( pool_hash: String, #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); - - let pool_blocks_current_epoch = dp + let pool_blocks_current_epoch = data_provider()? .pool_blocks_current_epoch(&pool_hash) .await .map_err(|_| RESTError::Custom("Couldn't find the quantity of blocks minted by the given pool in current epoch".to_string()))?; @@ -625,11 +578,7 @@ pub async fn pool_reward_recipients( pool_hash: String, #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); - - let pool_reward_recipients = dp + let pool_reward_recipients = data_provider()? .pool_reward_recipients(&pool_hash) .await .map_err(|_| RESTError::Custom("Couldn't find the quantity of delegators that received rewards".to_string()))?; @@ -647,11 +596,7 @@ pub async fn pool_last_reward_earned_epoch( pool_hash: String, #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); - - let pool_last_reward_earned_epoch = dp + let pool_last_reward_earned_epoch = data_provider()? .pool_last_reward_earned_epoch(&pool_hash) .await .map_err(|_| RESTError::Custom("Couldn't find the last epoch when the given pool distributed rewards".to_string()))?; @@ -670,11 +615,7 @@ pub async fn pool_declared_pledge( pool_hash: String, #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); - - let pool_declared_pledge = dp + let pool_declared_pledge = data_provider()? .pool_declared_pledge(&pool_hash) .await .map_err(|_| RESTError::Custom("Couldn't find the amount of Ada pledged by the given pool".to_string()))?; @@ -692,11 +633,7 @@ pub async fn pool_margin_cost( pool_hash: String, #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); - - let pool_margin_cost = dp + let pool_margin_cost = data_provider()? .pool_margin_cost(&pool_hash) .await .map_err(|_| RESTError::Custom("Couldn't find the margin cost of the given pool".to_string()))?; @@ -714,11 +651,7 @@ pub async fn pool_fixed_cost( pool_hash: String, #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); - - let pool_fixed_cost = dp + let pool_fixed_cost = data_provider()? .pool_fixed_cost(&pool_hash) .await .map_err(|_| RESTError::Custom("Couldn't find the fixed cost of the given pool".to_string()))?; @@ -736,11 +669,7 @@ pub async fn pool_reward_address( pool_hash: String, #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); - - let pool_reward_address = dp + let pool_reward_address = data_provider()? .pool_reward_address(&pool_hash) .await .map_err(|_| RESTError::Custom("Couldn't find the reward address of the given pool".to_string()))?; @@ -758,11 +687,7 @@ pub async fn pool_owner( pool_hash: String, #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); - - let pool_owner = dp + let pool_owner = data_provider()? .pool_owner(&pool_hash) .await .map_err(|_| RESTError::Custom("Couldn't find the owner of the given pool".to_string()))?; @@ -780,11 +705,7 @@ pub async fn pool_registration( pool_hash: String, #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); - - let pool_registration = dp + let pool_registration = data_provider()? .pool_registration(&pool_hash) .await .map_err(|_| RESTError::Custom("Couldn't find the epoch in which the given pool made its latest registration".to_string()))?; @@ -802,11 +723,7 @@ pub async fn pool_retirement( pool_hash: String, #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); - - let pool_retirement = dp + let pool_retirement = data_provider()? .pool_retirement(&pool_hash) .await .map_err(|_| RESTError::Custom("Couldn't find the epoch in which the given pool retired".to_string()))?; @@ -824,11 +741,7 @@ pub async fn pool_url( pool_hash: String, #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); - - let pool_url = dp + let pool_url = data_provider()? .pool_url(&pool_hash) .await .map_err(|_| RESTError::Custom("Couldn't find the url in which the given pool stores its metadata".to_string()))?; @@ -846,11 +759,7 @@ pub async fn pool_ticker( pool_hash: String, #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); - - let pool_ticker = dp + let pool_ticker = data_provider()? .pool_ticker(&pool_hash) .await .map_err(|_| RESTError::Custom("Couldn't find the ticker of the given stake pool".to_string()))?; @@ -868,11 +777,7 @@ pub async fn pool_metadata_json( pool_hash: String, #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); - - let pool_metadata_json = dp + let pool_metadata_json = data_provider()? .pool_metadata_json(&pool_hash) .await .map_err(|_| RESTError::Custom("Couldn't find the metadata JSON of the given stake pool".to_string()))?; @@ -890,11 +795,7 @@ pub async fn pool_name( pool_hash: String, #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); - - let pool_name = dp + let pool_name = data_provider()? .pool_name(&pool_hash) .await .map_err(|_| RESTError::Custom("Couldn't find the name of the given stake pool".to_string()))?; @@ -912,11 +813,7 @@ pub async fn pool_homepage( pool_hash: String, #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); - - let pool_homepage = dp + let pool_homepage = data_provider()? .pool_homepage(&pool_hash) .await .map_err(|_| RESTError::Custom("Couldn't find the homepage of the given stake pool".to_string()))?; @@ -934,11 +831,7 @@ pub async fn pool_description( pool_hash: String, #[filter = "with_auth"] _user_id: String, ) -> Result, Rejection> { - let dp = crate::DataProvider::new(crate::DBSyncProvider::new(crate::Config { - db_path: std::env::var("DBSYNC_URL").map_err(|_| warp::reject::not_found())?, - })); - - let pool_description = dp + let pool_description = data_provider()? .pool_description(&pool_hash) .await .map_err(|_| RESTError::Custom("Couldn't find the description of the given stake pool".to_string()))?;