├── .gitignore
├── examples
    ├── README.md
    ├── simple_request.rs
    ├── submit_transaction.rs
    ├── ipfs.rs
    ├── fetch_all.rs
    └── all_requests.rs
├── default.nix
├── src
    ├── api
    │   ├── endpoints
    │   │   ├── mod.rs
    │   │   ├── mempool.rs
    │   │   ├── ledger.rs
    │   │   ├── network.rs
    │   │   ├── utils.rs
    │   │   ├── health.rs
    │   │   ├── metrics.rs
    │   │   ├── scripts.rs
    │   │   ├── nutlink.rs
    │   │   ├── metadata.rs
    │   │   ├── blocks.rs
    │   │   ├── assets.rs
    │   │   ├── addresses.rs
    │   │   ├── pools.rs
    │   │   ├── epochs.rs
    │   │   ├── accounts.rs
    │   │   └── transactions.rs
    │   └── mod.rs
    ├── types.rs
    ├── pagination.rs
    ├── lib.rs
    ├── utils.rs
    ├── settings.rs
    ├── error.rs
    ├── request.rs
    ├── url.rs
    └── ipfs.rs
├── rustfmt.toml
├── .vscode
    └── settings.json
├── nix
    ├── sources.json
    └── sources.nix
├── Cargo.toml
├── .github
    └── workflows
    │   └── ci.yaml
├── README.md
├── CHANGELOG.md
├── ENDPOINTS.md
└── LICENSE


/.gitignore:
--------------------------------------------------------------------------------
1 | /target
2 | blockfrost.toml
3 | .blockfrost.toml
4 | 


--------------------------------------------------------------------------------
/examples/README.md:
--------------------------------------------------------------------------------
1 | # Examples
2 | 
3 | Before checking the examples be sure that you are using a compatible version of
4 | this crate, otherwise, the examples may not work on your project.
5 | 


--------------------------------------------------------------------------------
/default.nix:
--------------------------------------------------------------------------------
 1 | let
 2 |   pkgs = import <nixpkgs> { };
 3 |   sources = import ./nix/sources.nix;
 4 |   naersk = pkgs.callPackage sources.naersk { };
 5 | in
 6 |   naersk.buildPackage {
 7 |     src = ./.;
 8 |     buildInputs = [ pkgs.pkg-config pkgs.openssl ];
 9 |   }
10 | 


--------------------------------------------------------------------------------
/src/api/endpoints/mod.rs:
--------------------------------------------------------------------------------
 1 | mod accounts;
 2 | mod addresses;
 3 | mod assets;
 4 | mod blocks;
 5 | mod epochs;
 6 | mod health;
 7 | mod ledger;
 8 | mod mempool;
 9 | mod metadata;
10 | mod metrics;
11 | mod network;
12 | mod nutlink;
13 | mod pools;
14 | mod scripts;
15 | mod transactions;
16 | mod utils;
17 | 


--------------------------------------------------------------------------------
/rustfmt.toml:
--------------------------------------------------------------------------------
 1 | # Sets the maximum line length. Code will be wrapped beyond this length.
 2 | max_width = 100
 3 | 
 4 | # Use spaces for indentation rather than tabs.
 5 | hard_tabs = false
 6 | 
 7 | # Configure the visual indentation of arguments and parameters.
 8 | fn_params_layout = "Compressed"
 9 | 
10 | # Controls whether to put `else` on a new line.
11 | newline_style = "Auto"
12 | 


--------------------------------------------------------------------------------
/examples/simple_request.rs:
--------------------------------------------------------------------------------
 1 | use blockfrost::{BlockfrostAPI, BlockfrostResult};
 2 | 
 3 | fn build_api() -> BlockfrostResult<BlockfrostAPI> {
 4 |     let api = BlockfrostAPI::new(
 5 |         "mainnetxvMK4xOpp5mHJgihi055KDLU64JJv2be",
 6 |         Default::default(),
 7 |     );
 8 | 
 9 |     Ok(api)
10 | }
11 | 
12 | #[tokio::main]
13 | async fn main() -> BlockfrostResult<()> {
14 |     let api = build_api()?;
15 |     let genesis = api.genesis().await?;
16 | 
17 |     println!("{genesis:#?}");
18 |     Ok(())
19 | }
20 | 


--------------------------------------------------------------------------------
/.vscode/settings.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "cSpell.words": [
 3 |     "ADAUSD",
 4 |     "Adress",
 5 |     "Bech",
 6 |     "blockfrost",
 7 |     "CARDANO",
 8 |     "cbor",
 9 |     "Clippy",
10 |     "decentralisation",
11 |     "delegators",
12 |     "deregistration",
13 |     "IFPS",
14 |     "ipfs",
15 |     "Lovelaces",
16 |     "mirs",
17 |     "naersk",
18 |     "nixpkgs",
19 |     "Nutlink",
20 |     "openapi",
21 |     "preprodnet",
22 |     "previewnet",
23 |     "println",
24 |     "redemeers",
25 |     "reqwest",
26 |     "retriving",
27 |     "rustfmt",
28 |     "serialised",
29 |     "stakenuts",
30 |     "thiserror",
31 |     "timelock",
32 |     "UTXO",
33 |     "utxos",
34 |     "xpub"
35 |   ]
36 | }
37 | 


--------------------------------------------------------------------------------
/examples/submit_transaction.rs:
--------------------------------------------------------------------------------
 1 | use blockfrost::{BlockFrostSettings, BlockfrostAPI, BlockfrostResult};
 2 | 
 3 | fn build_api() -> BlockfrostResult<BlockfrostAPI> {
 4 |     let api = BlockfrostAPI::new(
 5 |         "mainnetxvMK4xOpp5mHJgihi055KDLU64JJv2be",
 6 |         BlockFrostSettings::new(),
 7 |     );
 8 |     Ok(api)
 9 | }
10 | 
11 | #[tokio::main]
12 | async fn main() -> BlockfrostResult<()> {
13 |     let api = build_api()?;
14 | 
15 |     // Should contain the correct cbor contents
16 |     let transaction_data = vec![0; 1024]; // Just an example (will fail)
17 |     let transaction_hash = api.transactions_submit(transaction_data).await?;
18 | 
19 |     // At this point, you should probably save the transaction_hash
20 |     println!("{transaction_hash}");
21 | 
22 |     Ok(())
23 | }
24 | 


--------------------------------------------------------------------------------
/src/api/endpoints/mempool.rs:
--------------------------------------------------------------------------------
 1 | use crate::*;
 2 | use blockfrost_openapi::models::{
 3 |     mempool_content_inner::MempoolContentInner, mempool_tx_content::MempoolTxContent,
 4 | };
 5 | 
 6 | impl BlockfrostAPI {
 7 |     pub async fn mempool(
 8 |         &self, pagination: Pagination,
 9 |     ) -> BlockfrostResult<Vec<MempoolContentInner>> {
10 |         self.call_paged_endpoint("/mempool", pagination).await
11 |     }
12 | 
13 |     pub async fn mempool_hash(&self, hash: &str) -> BlockfrostResult<MempoolTxContent> {
14 |         self.call_endpoint(format!("/mempool/{hash}").as_str())
15 |             .await
16 |     }
17 |     pub async fn mempool_addresses_address(
18 |         &self, address: &str, pagination: Pagination,
19 |     ) -> BlockfrostResult<Vec<MempoolContentInner>> {
20 |         self.call_paged_endpoint(format!("/mempool/addresses/{address}").as_str(), pagination)
21 |             .await
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/api/endpoints/ledger.rs:
--------------------------------------------------------------------------------
 1 | use crate::*;
 2 | use blockfrost_openapi::models::genesis_content::GenesisContent;
 3 | 
 4 | impl BlockfrostAPI {
 5 |     pub async fn genesis(&self) -> BlockfrostResult<GenesisContent> {
 6 |         self.call_endpoint("/genesis").await
 7 |     }
 8 | }
 9 | 
10 | #[cfg(test)]
11 | mod tests {
12 |     use super::*;
13 |     use serde_json::json;
14 | 
15 |     #[test]
16 |     fn test_genesis() {
17 |         let json_value = json!({
18 |           "active_slots_coefficient": 0.05,
19 |           "update_quorum": 5,
20 |           "max_lovelace_supply": "45000000000000000",
21 |           "network_magic": 764824073,
22 |           "epoch_length": 432000,
23 |           "system_start": 1506203091,
24 |           "slots_per_kes_period": 129600,
25 |           "slot_length": 1,
26 |           "max_kes_evolutions": 62,
27 |           "security_param": 2160
28 |         });
29 | 
30 |         serde_json::from_value::<GenesisContent>(json_value).unwrap();
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/nix/sources.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "naersk": {
 3 |     "branch": "master",
 4 |     "description": "Build rust crates in Nix. No configuration, no code generation, no IFD. Sandbox friendly. [maintainer: @Patryk27]",
 5 |     "homepage": "",
 6 |     "owner": "nix-community",
 7 |     "repo": "naersk",
 8 |     "rev": "6944160c19cb591eb85bbf9b2f2768a935623ed3",
 9 |     "sha256": "01i282zrx651mpvnmlgk4fgwg56nbr1yljpzcj5irqxf18cqx3gn",
10 |     "type": "tarball",
11 |     "url": "https://github.com/nix-community/naersk/archive/6944160c19cb591eb85bbf9b2f2768a935623ed3.tar.gz",
12 |     "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
13 |   },
14 |   "nixpkgs": {
15 |     "branch": "release-21.05",
16 |     "description": "Nix Packages collection",
17 |     "homepage": "",
18 |     "owner": "NixOS",
19 |     "repo": "nixpkgs",
20 |     "rev": "5f244caea76105b63d826911b2a1563d33ff1cdc",
21 |     "sha256": "1xlgynfw9svy7nvh9nkxsxdzncv9hg99gbvbwv3gmrhmzc3sar75",
22 |     "type": "tarball",
23 |     "url": "https://github.com/NixOS/nixpkgs/archive/5f244caea76105b63d826911b2a1563d33ff1cdc.tar.gz",
24 |     "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
25 |   }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/api/endpoints/network.rs:
--------------------------------------------------------------------------------
 1 | use crate::*;
 2 | use blockfrost_openapi::models::{network::Network, network_eras_inner::NetworkErasInner};
 3 | 
 4 | impl BlockfrostAPI {
 5 |     pub async fn network(&self) -> BlockfrostResult<Network> {
 6 |         self.call_endpoint("/network").await
 7 |     }
 8 | 
 9 |     pub async fn network_eras(&self) -> BlockfrostResult<Vec<NetworkErasInner>> {
10 |         self.call_endpoint("/network/eras").await
11 |     }
12 | }
13 | 
14 | #[cfg(test)]
15 | mod tests {
16 |     use blockfrost_openapi::models::network::Network;
17 |     use serde_json::json;
18 | 
19 |     #[test]
20 |     fn test_network() {
21 |         let json_value = json!({
22 |           "supply": {
23 |             "max": "45000000000000000",
24 |             "total": "32890715183299160",
25 |             "circulating": "32412601976210393",
26 |             "locked": "125006953355",
27 |             "treasury": "98635632000000",
28 |             "reserves": "46635632000000"
29 |           },
30 |           "stake": {
31 |             "live": "23204950463991654",
32 |             "active": "22210233523456321"
33 |           }
34 |         });
35 | 
36 |         serde_json::from_value::<Network>(json_value).unwrap();
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/types.rs:
--------------------------------------------------------------------------------
 1 | // Use this module as an interface to export all types declared inside of endpoints/
 2 | //
 3 | // These are not used in here, just exporting
 4 | pub use crate::ipfs::{IpfsAdd, IpfsPinList, IpfsPinState, IpfsPinUpdate};
 5 | 
 6 | /// Enum for any possible JSON value.
 7 | ///
 8 | /// Declared as the following:
 9 | ///
10 | /// ```no_run
11 | /// # use f64 as Number;
12 | /// # use std::collections::HashMap as Map;
13 | /// pub enum Value {
14 | ///     Null,
15 | ///     Bool(bool),
16 | ///     Number(Number),
17 | ///     String(String),
18 | ///     Array(Vec<Value>),
19 | ///     Object(Map<String, Value>),
20 | /// }
21 | /// ```
22 | pub type JsonValue = serde_json::Value;
23 | 
24 | /// Integer used in other types.
25 | ///
26 | /// A signed 128-bit integer can store up to 2^127, or 340282366920938463463374607431768211456.
27 | ///
28 | /// This integer can store a number with 38 digits, the max supply of ADA is 45 billion (11 digits).
29 | pub type Integer = i128;
30 | 
31 | /// Float used in other types.
32 | pub type Float = f64;
33 | 
34 | /// JSON Map (or JSON object) made of key-value pairs.
35 | ///
36 | /// Used in types:
37 | /// [`EpochParameters`]
38 | /// [`AssetDetails`]
39 | pub type JsonMap = serde_json::Map<String, JsonValue>;
40 | 


--------------------------------------------------------------------------------
/src/pagination.rs:
--------------------------------------------------------------------------------
 1 | use crate::{DEFAULT_ORDER, DEFAULT_PAGINATION_PAGE_COUNT, DEFAULT_PAGINATION_PAGE_ITEMS_COUNT};
 2 | 
 3 | #[derive(Clone, Copy)]
 4 | pub struct Pagination {
 5 |     pub fetch_all: bool,
 6 |     pub count: usize,
 7 |     pub page: usize,
 8 |     pub order: Order,
 9 | }
10 | 
11 | impl Default for Pagination {
12 |     fn default() -> Self {
13 |         Pagination {
14 |             fetch_all: false,
15 |             count: DEFAULT_PAGINATION_PAGE_ITEMS_COUNT,
16 |             page: DEFAULT_PAGINATION_PAGE_COUNT,
17 |             order: DEFAULT_ORDER,
18 |         }
19 |     }
20 | }
21 | 
22 | impl Pagination {
23 |     pub fn new(order: Order, page: usize, count: usize) -> Self {
24 |         Pagination {
25 |             fetch_all: false,
26 |             order,
27 |             page,
28 |             count,
29 |         }
30 |     }
31 | 
32 |     pub fn all() -> Self {
33 |         Pagination {
34 |             fetch_all: true,
35 |             ..Default::default()
36 |         }
37 |     }
38 | 
39 |     pub fn order_to_string(&self) -> String {
40 |         match self.order {
41 |             Order::Asc => "asc".to_string(),
42 |             Order::Desc => "desc".to_string(),
43 |         }
44 |     }
45 | }
46 | 
47 | #[derive(Clone, Copy)]
48 | pub enum Order {
49 |     Asc,
50 |     Desc,
51 | }
52 | 


--------------------------------------------------------------------------------
/examples/ipfs.rs:
--------------------------------------------------------------------------------
 1 | use blockfrost::{BlockfrostIPFS, BlockfrostResult, IpfsSettings};
 2 | use std::fs;
 3 | 
 4 | fn build_ipfs() -> BlockfrostResult<BlockfrostIPFS> {
 5 |     let api = BlockfrostIPFS::new(
 6 |         "mainnetxvMK4xOpp5mHJgihi055KDLU64JJv2be",
 7 |         IpfsSettings::new(),
 8 |     );
 9 |     Ok(api)
10 | }
11 | 
12 | #[tokio::main]
13 | async fn main() -> BlockfrostResult<()> {
14 |     let ipfs = build_ipfs()?;
15 |     let file = fs::read_to_string("/etc/fstab")?.into_bytes();
16 | 
17 |     // Add file
18 |     let added_file = ipfs.add(file).await?;
19 |     println!("{added_file:#?}");
20 |     let hash = &added_file.ipfs_hash;
21 | 
22 |     // Pin it
23 |     let pinned_file = ipfs.pin_add(hash).await?;
24 |     println!("{pinned_file:#?}");
25 |     let hash = &pinned_file.ipfs_hash;
26 | 
27 |     // List pins
28 |     let pin_list = ipfs.pin_list().await?;
29 |     println!("{pin_list:#?}");
30 | 
31 |     // List pin by ipfs_hash (id)
32 |     let pin_list_by_id = ipfs.pin_list_by_id(hash).await?;
33 |     println!("{pin_list_by_id:#?}");
34 | 
35 |     // Query contents
36 |     let gateway = ipfs.gateway(hash).await?;
37 |     let string = String::from_utf8(gateway).unwrap();
38 |     println!("content: '{string:#?}'");
39 | 
40 |     // Remove pin
41 |     let pin_removed = ipfs.pin_remove(hash).await?;
42 |     println!("{pin_removed:#?}");
43 | 
44 |     Ok(())
45 | }
46 | 


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "blockfrost"
 3 | version = "1.1.0"
 4 | edition = "2021"
 5 | keywords = ["blockfrost", "blockchain", "cardano", "ipfs", "nft"]
 6 | categories = ["api-bindings", "asynchronous", "cryptography::cryptocurrencies"]
 7 | description = "A Rust SDK for Blockfrost.io API"
 8 | license = "Apache-2.0"
 9 | repository = "https://github.com/blockfrost/blockfrost-rust"
10 | homepage = "https://blockfrost.io"
11 | 
12 | [dependencies]
13 | blockfrost-openapi = "0.1.75"
14 | futures = "0.3.31"
15 | futures-timer = "3.0.3"
16 | reqwest = { version = "0.12.9", default-features = false, features = [
17 |     "http2",
18 |     "charset",
19 |     "macos-system-configuration",
20 |     "multipart",
21 |     "json",
22 | ] }
23 | serde = { version = "1.0.130", features = ["derive"] }
24 | serde_json = "1.0.128"
25 | url = "2.5.2"
26 | thiserror = "2.0.3"
27 | 
28 | [dev-dependencies]
29 | httpmock = "0.7.0"
30 | rstest = "0.25.0"
31 | tokio = { version = "1.12.0", features = ["macros", "rt-multi-thread"] }
32 | 
33 | [features]
34 | default = ["default-tls"]
35 | default-tls = ["reqwest/default-tls"]
36 | rustls-tls = ["reqwest/rustls-tls"]
37 | rustls-tls-manual-roots = ["reqwest/rustls-tls-manual-roots"]
38 | rustls-tls-webpki-roots = ["reqwest/rustls-tls-webpki-roots"]
39 | rustls-tls-native-roots = ["reqwest/rustls-tls-native-roots"]
40 | 
41 | [lints.clippy]
42 | uninlined_format_args = "deny"
43 | 


--------------------------------------------------------------------------------
/src/lib.rs:
--------------------------------------------------------------------------------
 1 | #![doc(
 2 |     html_logo_url = "https://raw.githubusercontent.com/blockfrost/blockfrost-rust/master/docs-logo.svg"
 3 | )]
 4 | #![doc = include_str!("../README.md")]
 5 | mod api;
 6 | mod ipfs;
 7 | mod pagination;
 8 | mod request;
 9 | mod settings;
10 | mod url;
11 | mod utils;
12 | 
13 | pub mod error;
14 | pub mod types;
15 | pub use api::*;
16 | pub use error::*;
17 | pub use ipfs::BlockfrostIPFS;
18 | pub use pagination::Order;
19 | pub use pagination::Pagination;
20 | pub use settings::*;
21 | pub use types::*;
22 | 
23 | pub const CARDANO_MAINNET_URL: &str = "https://cardano-mainnet.blockfrost.io/api/v0";
24 | pub const CARDANO_PREPROD_URL: &str = "https://cardano-preprod.blockfrost.io/api/v0";
25 | pub const CARDANO_PREVIEW_URL: &str = "https://cardano-preview.blockfrost.io/api/v0";
26 | pub const CARDANO_TESTNET_URL: &str = "https://cardano-testnet.blockfrost.io/api/v0";
27 | pub const IPFS_URL: &str = "https://ipfs.blockfrost.io/api/v0";
28 | 
29 | pub const DEFAULT_API_VERSION: u32 = 0;
30 | pub const DEFAULT_BATCH_SIZE: u32 = 10;
31 | pub const DEFAULT_ORDER: Order = Order::Asc;
32 | pub const DEFAULT_PAGINATION_PAGE_COUNT: usize = 1;
33 | pub const DEFAULT_PAGINATION_PAGE_ITEMS_COUNT: usize = 100;
34 | 
35 | /// SDK version being used.
36 | ///
37 | /// This is sent on every request as a header.
38 | pub const USER_AGENT: &str = concat!("blockfrost-rust/", env!("CARGO_PKG_VERSION"));
39 | 


--------------------------------------------------------------------------------
/src/api/endpoints/utils.rs:
--------------------------------------------------------------------------------
 1 | use crate::{request::send_request, url::Url, *};
 2 | use blockfrost_openapi::models::utils_addresses_xpub::UtilsAddressesXpub;
 3 | use reqwest::{header::HeaderValue, Body, Method};
 4 | use serde_json::{from_str as json_from, Value};
 5 | 
 6 | impl BlockfrostAPI {
 7 |     pub async fn derive_address(
 8 |         &self, xpub: &str, role: &str, index: &str,
 9 |     ) -> BlockfrostResult<UtilsAddressesXpub> {
10 |         self.call_endpoint(&format!("/utils/addresses/xpub/{xpub}/{role}/{index}",))
11 |             .await
12 |     }
13 | 
14 |     pub async fn utils_tx_evaluate(&self, transaction_data: Vec<u8>) -> BlockfrostResult<Value> {
15 |         let body = Body::from(transaction_data);
16 |         let url = Url::from_endpoint(self.base_url.as_str(), "/utils/txs/evaluate")?;
17 | 
18 |         let request = self
19 |             .client
20 |             .request(Method::POST, &url)
21 |             .header("Content-Type", HeaderValue::from_static("application/cbor"))
22 |             .body(body);
23 | 
24 |         let (status, text) = send_request(request, self.settings.retry_settings)
25 |             .await
26 |             .map_err(|reason| BlockfrostError::Reqwest {
27 |                 url: url.clone(),
28 |                 reason,
29 |             })?;
30 | 
31 |         if !status.is_success() {
32 |             return Err(process_error_response(&text, status, &url));
33 |         }
34 | 
35 |         json_from(&text).map_err(|reason| json_error(url, text, reason))
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/examples/fetch_all.rs:
--------------------------------------------------------------------------------
 1 | use blockfrost::{BlockFrostSettings, BlockfrostAPI, BlockfrostResult, Pagination};
 2 | 
 3 | fn build_api_preprod() -> BlockfrostResult<BlockfrostAPI> {
 4 |     let settings = BlockFrostSettings::new();
 5 |     let api = BlockfrostAPI::new("preprododflHjPhpRp4NzRFL1m9zzd6ZJb1RjYi", settings);
 6 | 
 7 |     Ok(api)
 8 | }
 9 | 
10 | fn build_api_preview() -> BlockfrostResult<BlockfrostAPI> {
11 |     let settings = BlockFrostSettings::new();
12 |     let api = BlockfrostAPI::new("previewy2pbyga8FifUwJSverBCwhESegV6I7gT", settings);
13 | 
14 |     Ok(api)
15 | }
16 | 
17 | #[tokio::main]
18 | async fn main() -> BlockfrostResult<()> {
19 |     let pagination_all = Pagination::all();
20 | 
21 |     println!("Fetching ...");
22 | 
23 |     let all_utxos_for_asset = build_api_preprod()?
24 |         .addresses_utxos_asset(
25 |             "addr_test1wz2mzj532enpgu5vgwxuh249fpknx5ft9wxse2876z0mp2q89ye7k",
26 |             "c6e65ba7878b2f8ea0ad39287d3e2fd256dc5c4160fc19bdf4c4d87e7447454e53",
27 |             pagination_all,
28 |         )
29 |         .await;
30 | 
31 |     println!(
32 |         "count of all all_utxos_for_asset: {:#?}",
33 |         all_utxos_for_asset?.len()
34 |     );
35 | 
36 |     let all_utxos = build_api_preview()?
37 |         .addresses_utxos(
38 |             "addr_test1qqcxj57pwhesgkty9uzyyzq6hnl983nnzfug7f99dsntxayxvw0zufye5rc6nz7hcetdsx0ex03wjdrg8xrw9jen2lyslqawdk",
39 |             pagination_all,
40 |         )
41 |         .await;
42 | 
43 |     println!("count of all utxos: {:#?}", all_utxos?.len());
44 | 
45 |     Ok(())
46 | }
47 | 


--------------------------------------------------------------------------------
/src/api/endpoints/health.rs:
--------------------------------------------------------------------------------
 1 | use crate::*;
 2 | use blockfrost_openapi::models::{
 3 |     __get_200_response::Get200Response, _health_clock_get_200_response::HealthClockGet200Response,
 4 |     _health_get_200_response::HealthGet200Response,
 5 | };
 6 | 
 7 | impl BlockfrostAPI {
 8 |     /// Root endpoint, points end users to documentation.
 9 |     pub async fn root(&self) -> BlockfrostResult<Get200Response> {
10 |         self.call_endpoint("/").await
11 |     }
12 | 
13 |     /// Backend health status as a boolean.
14 |     pub async fn health(&self) -> BlockfrostResult<HealthGet200Response> {
15 |         self.call_endpoint("/health").await
16 |     }
17 | 
18 |     /// Current backend time.
19 |     pub async fn health_clock(&self) -> BlockfrostResult<HealthClockGet200Response> {
20 |         self.call_endpoint("/health/clock").await
21 |     }
22 | }
23 | 
24 | #[cfg(test)]
25 | mod tests {
26 |     use super::*;
27 |     use serde_json::json;
28 | 
29 |     #[test]
30 |     fn test_root() {
31 |         let json_value = json!({
32 |             "url": "https://blockfrost.io/",
33 |             "version": "0.1.0"
34 |         });
35 | 
36 |         serde_json::from_value::<Get200Response>(json_value).unwrap();
37 |     }
38 | 
39 |     #[test]
40 |     fn test_health() {
41 |         let json_value = json!({
42 |             "is_healthy": true,
43 |         });
44 | 
45 |         serde_json::from_value::<HealthGet200Response>(json_value).unwrap();
46 |     }
47 | 
48 |     #[test]
49 |     fn test_health_clock() {
50 |         let json_value = json!({
51 |             "is_healthy": true,
52 |             "server_time": "1603400958947",
53 |         });
54 | 
55 |         serde_json::from_value::<HealthGet200Response>(json_value).unwrap();
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/src/utils.rs:
--------------------------------------------------------------------------------
 1 | use crate::USER_AGENT;
 2 | use reqwest::{
 3 |     header::{HeaderMap, HeaderName, HeaderValue},
 4 |     Client,
 5 | };
 6 | use serde_json::{from_str as json_from, Value as JsonValue};
 7 | use std::{collections::HashMap, str::FromStr};
 8 | 
 9 | pub(crate) fn try_formatting_json(text: &str) -> serde_json::Result<String> {
10 |     let json = json_from::<JsonValue>(text)?;
11 | 
12 |     serde_json::to_string_pretty(&json)
13 | }
14 | 
15 | pub(crate) fn create_client_with_project_id(
16 |     project_id: impl AsRef<str>, headers: &HashMap<String, String>,
17 | ) -> Client {
18 |     let header_map = build_header_map(project_id.as_ref(), headers);
19 |     // Safety: This unwrap is guaranteed to never fail if we only call .default_headers()
20 |     Client::builder()
21 |         .default_headers(header_map)
22 |         .build()
23 |         .unwrap()
24 | }
25 | 
26 | pub(crate) fn build_header_map(project_id: &str, headers: &HashMap<String, String>) -> HeaderMap {
27 |     let mut header_map = HeaderMap::new();
28 |     let mut project_id = HeaderValue::from_str(project_id).unwrap_or_else(|_| {
29 |         panic!(
30 |             "Cannot create reqwest::Client because given project_id '{project_id}'cannot be parsed as HeaderValue",
31 |         )
32 |     });
33 |     project_id.set_sensitive(true);
34 |     let user_agent = HeaderValue::from_static(USER_AGENT);
35 | 
36 |     header_map.insert("project_id", project_id);
37 |     header_map.insert("User-Agent", user_agent);
38 |     for (key, val) in headers.iter() {
39 |         let (Ok(key), Ok(val)) = (HeaderName::from_str(key), HeaderValue::from_str(val)) else {
40 |             panic!("Header \"{key}: {val}\" is invalid")
41 |         };
42 |         header_map.insert(key, val);
43 |     }
44 |     header_map
45 | }
46 | 


--------------------------------------------------------------------------------
/src/api/endpoints/metrics.rs:
--------------------------------------------------------------------------------
 1 | use crate::*;
 2 | use blockfrost_openapi::models::{
 3 |     metrics_endpoints_inner::MetricsEndpointsInner, metrics_inner::MetricsInner,
 4 | };
 5 | 
 6 | impl BlockfrostAPI {
 7 |     pub async fn metrics(&self, pagination: Pagination) -> BlockfrostResult<Vec<MetricsInner>> {
 8 |         self.call_paged_endpoint("/metrics", pagination).await
 9 |     }
10 | 
11 |     pub async fn metrics_endpoints(
12 |         &self, pagination: Pagination,
13 |     ) -> BlockfrostResult<Vec<MetricsEndpointsInner>> {
14 |         self.call_paged_endpoint("/metrics/endpoints", pagination)
15 |             .await
16 |     }
17 | }
18 | 
19 | #[cfg(test)]
20 | mod tests {
21 |     use super::*;
22 |     use serde_json::json;
23 | 
24 |     #[test]
25 |     fn test_metrics() {
26 |         let json_value = json!([
27 |           {
28 |             "time": 1612543884,
29 |             "calls": 42
30 |           },
31 |           {
32 |             "time": 1614523884,
33 |             "calls": 6942
34 |           }
35 |         ]);
36 | 
37 |         serde_json::from_value::<Vec<MetricsInner>>(json_value).unwrap();
38 |     }
39 | 
40 |     #[test]
41 |     fn test_metrics_endpoints() {
42 |         let json_value = json!([
43 |           {
44 |             "time": 1612543814,
45 |             "calls": 182,
46 |             "endpoint": "block"
47 |           },
48 |           {
49 |             "time": 1612543814,
50 |             "calls": 42,
51 |             "endpoint": "epoch"
52 |           },
53 |           {
54 |             "time": 1612543812,
55 |             "calls": 775,
56 |             "endpoint": "block"
57 |           },
58 |           {
59 |             "time": 1612523884,
60 |             "calls": 4,
61 |             "endpoint": "epoch"
62 |           },
63 |           {
64 |             "time": 1612553884,
65 |             "calls": 89794,
66 |             "endpoint": "block"
67 |           }
68 |         ]);
69 | 
70 |         serde_json::from_value::<Vec<MetricsEndpointsInner>>(json_value).unwrap();
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/.github/workflows/ci.yaml:
--------------------------------------------------------------------------------
 1 | on: [push]
 2 | name: Continuous Integration
 3 | 
 4 | jobs:
 5 |   # Check
 6 |   check:
 7 |     name: Check
 8 |     runs-on: ubuntu-latest
 9 |     steps:
10 |       - name: Checkout sources
11 |         uses: actions/checkout@v2
12 | 
13 |       - name: Install stable toolchain
14 |         uses: actions-rs/toolchain@v1
15 |         with:
16 |           profile: minimal
17 |           toolchain: stable
18 |           override: true
19 | 
20 |       - name: Run cargo check
21 |         uses: actions-rs/cargo@v1
22 |         with:
23 |           command: check
24 | 
25 |   # Unit tests
26 |   test:
27 |     name: Unit Tests
28 |     runs-on: ubuntu-latest
29 |     steps:
30 |       - name: Checkout sources
31 |         uses: actions/checkout@v2
32 | 
33 |       - name: Install stable toolchain
34 |         uses: actions-rs/toolchain@v1
35 |         with:
36 |           profile: minimal
37 |           toolchain: stable
38 |           override: true
39 | 
40 |       - name: Run cargo test
41 |         uses: actions-rs/cargo@v1
42 |         with:
43 |           command: test
44 | 
45 |   # Lints and Clippy
46 |   lints:
47 |     name: Lints
48 |     runs-on: ubuntu-latest
49 |     steps:
50 |       - name: Checkout sources
51 |         uses: actions/checkout@v2
52 | 
53 |       - name: Install stable toolchain
54 |         uses: actions-rs/toolchain@v1
55 |         with:
56 |           profile: minimal
57 |           toolchain: stable
58 |           override: true
59 |           components: rustfmt, clippy
60 | 
61 |       - name: Run cargo fmt
62 |         uses: actions-rs/cargo@v1
63 |         with:
64 |           command: fmt
65 |           args: --all -- --check
66 | 
67 |       - name: Run cargo clippy
68 |         uses: actions-rs/cargo@v1
69 |         with:
70 |           command: clippy
71 |           args: -- -D warnings
72 | 
73 |   # Nix build
74 |   nix-build:
75 |     name: Nix Build
76 |     runs-on: ubuntu-latest
77 |     steps:
78 |       - uses: actions/checkout@v2
79 |       - uses: cachix/install-nix-action@v13
80 |         with:
81 |           nix_path: nixpkgs=channel:nixos-unstable
82 |       - run: nix-build
83 | 


--------------------------------------------------------------------------------
/src/settings.rs:
--------------------------------------------------------------------------------
 1 | use std::{collections::HashMap, time::Duration};
 2 | 
 3 | #[derive(Debug, Clone)]
 4 | #[non_exhaustive]
 5 | pub struct BlockFrostSettings {
 6 |     pub base_url: Option<String>,
 7 |     pub retry_settings: RetrySettings,
 8 |     pub headers: HashMap<String, String>,
 9 | }
10 | 
11 | impl BlockFrostSettings {
12 |     pub fn new() -> Self {
13 |         Self {
14 |             base_url: None,
15 |             retry_settings: RetrySettings::default(),
16 |             headers: HashMap::new(),
17 |         }
18 |     }
19 | }
20 | 
21 | #[derive(Debug, Clone)]
22 | #[non_exhaustive]
23 | pub struct IpfsSettings {
24 |     pub retry_settings: RetrySettings,
25 |     pub headers: HashMap<String, String>,
26 | }
27 | 
28 | impl IpfsSettings {
29 |     /// Create a customizable [`IpfsSettings`].
30 |     ///
31 |     /// # Default settings:
32 |     ///
33 |     /// - Network: [`IPFS_NETWORK`].
34 |     /// - Query parameters: empty.
35 |     /// - Retry settings: disabled.
36 |     pub fn new() -> Self {
37 |         Self {
38 |             retry_settings: RetrySettings::default(),
39 |             headers: HashMap::new(),
40 |         }
41 |     }
42 | }
43 | 
44 | /// Uses the default network [`CARDANO_MAINNET_NETWORK`].
45 | impl Default for BlockFrostSettings {
46 |     fn default() -> Self {
47 |         Self::new()
48 |     }
49 | }
50 | 
51 | /// Uses the default network [`IPFS_NETWORK`].
52 | impl Default for IpfsSettings {
53 |     fn default() -> Self {
54 |         Self::new()
55 |     }
56 | }
57 | 
58 | /// Settings for retrying when API rate limit is reached.
59 | ///
60 | /// Amount and delay are set to zero by default, you will need to change both to enable retrying.
61 | ///
62 | /// Check different BlockFrost plans and their limits at <https://blockfrost.io/#pricing>.
63 | ///
64 | /// Note: You can disable delay between retries with [`Duration::ZERO`].
65 | #[derive(Default, Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
66 | pub struct RetrySettings {
67 |     pub amount: u64,
68 |     pub delay: Duration,
69 | }
70 | 
71 | impl RetrySettings {
72 |     /// Create a new `RetrySettings`, with retry amount and delay.
73 |     pub fn new(amount: u64, delay: Duration) -> Self {
74 |         Self { amount, delay }
75 |     }
76 | }
77 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | <p align="center">
 2 |   <a href="https://crates.io/crates/blockfrost">
 3 |     <img src="https://img.shields.io/crates/v/blockfrost?color=2E83FA" alt="Crates.io link">
 4 |   </a>
 5 |   <a href="https://docs.rs/blockfrost">
 6 |     <img src="https://img.shields.io/docsrs/blockfrost?color=2E83FA" alt="Docs.rs link">
 7 |   </a>
 8 |   <a href="https://github.com/blockfrost/blockfrost-rust/blob/master/LICENSE">
 9 |     <img src="https://img.shields.io/crates/l/blockfrost?color=2E83FA" alt="License">
10 |   </a>
11 | </p>
12 | 
13 | <img src="https://blockfrost.io/images/logo.svg" width="250" align="right" height="90" style="margin-bottom: -50px">
14 | 
15 | # blockfrost-rust
16 | 
17 | <br>
18 | <p align="center">A Rust SDK for <a href="https://blockfrost.io">Blockfrost.io</a> API.</p>
19 | <p align="center">
20 |   <a href="#getting-started">Getting started</a> •
21 |   <a href="#installation">Installation</a> •
22 |   <a href="#examples">Examples</a> •
23 |   <a href="./ENDPOINTS.md">Endpoints</a>
24 | </p>
25 | 
26 | ## Getting started
27 | 
28 | To use this SDK you need to login at [blockfrost.io](https://blockfrost.io)
29 | and create a new project to receive an API key.
30 | 
31 | <img src="https://i.imgur.com/smY12ro.png">
32 | 
33 | ## Installation
34 | 
35 | Add to your project's `Cargo.toml`:
36 | 
37 | ```toml
38 | blockfrost = "1.1.0"
39 | ```
40 | 
41 | ## Examples
42 | 
43 | All the examples are located at the [`examples/`] folder.
44 | 
45 | You might want to check [`all_requests.rs`] and [`ipfs.rs`].
46 | 
47 | Here is [`simple_request.rs`] with the basic setup necessary and no settings
48 | customization:
49 | 
50 | ```rust
51 | use blockfrost::{BlockfrostAPI, BlockfrostResult};
52 | 
53 | fn build_api() -> BlockfrostResult<BlockfrostAPI> {
54 |     let api = BlockfrostAPI::new("mainnetxvMK4xOpp5mHJgihi055KDLU64JJv2be", Default::default());
55 |     Ok(api)
56 | }
57 | 
58 | #[tokio::main]
59 | async fn main() -> blockfrost::BlockfrostResult<()> {
60 |     let api = build_api()?;
61 |     let genesis = api.genesis().await?;
62 | 
63 |     println!("{:#?}", genesis);
64 |     Ok(())
65 | }
66 | ```
67 | 
68 | [`examples/`]: https://github.com/blockfrost/blockfrost-rust/tree/master/examples
69 | [`all_requests.rs`]: https://github.com/blockfrost/blockfrost-rust/blob/master/examples/all_requests.rs
70 | [`ipfs.rs`]: https://github.com/blockfrost/blockfrost-rust/blob/master/examples/ipfs.rs
71 | [`simple_request.rs`]: https://github.com/blockfrost/blockfrost-rust/blob/master/examples/simple_request.rs
72 | 


--------------------------------------------------------------------------------
/src/api/mod.rs:
--------------------------------------------------------------------------------
 1 | pub(super) mod endpoints;
 2 | use crate::{
 3 |     pagination::Pagination,
 4 |     request::{fetch_all_pages, send_get_request},
 5 |     url::Url,
 6 |     utils::build_header_map,
 7 |     utils::create_client_with_project_id,
 8 |     BlockFrostSettings, BlockfrostError,
 9 | };
10 | use reqwest::ClientBuilder;
11 | 
12 | #[derive(Debug, Clone)]
13 | pub struct BlockfrostAPI {
14 |     base_url: String,
15 |     settings: BlockFrostSettings,
16 |     client: reqwest::Client,
17 | }
18 | 
19 | impl BlockfrostAPI {
20 |     pub fn new(project_id: &str, settings: BlockFrostSettings) -> Self {
21 |         let client = create_client_with_project_id(project_id, &settings.headers);
22 |         let base_url = settings
23 |             .base_url
24 |             .clone()
25 |             .unwrap_or_else(|| Url::get_base_url_from_project_id(project_id));
26 | 
27 |         Self {
28 |             settings,
29 |             client,
30 |             base_url,
31 |         }
32 |     }
33 | 
34 |     pub fn new_with_client(
35 |         project_id: &str, settings: BlockFrostSettings, client_builder: ClientBuilder,
36 |     ) -> reqwest::Result<Self> {
37 |         let base_url = settings
38 |             .base_url
39 |             .clone()
40 |             .unwrap_or_else(|| Url::get_base_url_from_project_id(project_id));
41 | 
42 |         client_builder
43 |             .default_headers(build_header_map(project_id, &settings.headers))
44 |             .build()
45 |             .map(|client| Self {
46 |                 settings,
47 |                 client,
48 |                 base_url,
49 |             })
50 |     }
51 | 
52 |     async fn call_endpoint<T>(&self, url_endpoint: &str) -> Result<T, BlockfrostError>
53 |     where
54 |         T: for<'de> serde::Deserialize<'de> + serde::de::DeserializeOwned,
55 |     {
56 |         let url = Url::from_endpoint(self.base_url.as_str(), url_endpoint)?;
57 | 
58 |         send_get_request(&self.client, url, self.settings.retry_settings).await
59 |     }
60 | 
61 |     async fn call_paged_endpoint<T>(
62 |         &self, url_endpoint: &str, pagination: Pagination,
63 |     ) -> Result<Vec<T>, BlockfrostError>
64 |     where
65 |         T: for<'de> serde::Deserialize<'de> + serde::de::DeserializeOwned,
66 |     {
67 |         let url = Url::from_paginated_endpoint(self.base_url.as_str(), url_endpoint, pagination)?;
68 | 
69 |         if pagination.fetch_all {
70 |             fetch_all_pages(
71 |                 &self.client,
72 |                 &url,
73 |                 self.settings.retry_settings,
74 |                 pagination,
75 |                 10,
76 |             )
77 |             .await
78 |         } else {
79 |             send_get_request(&self.client, url, self.settings.retry_settings).await
80 |         }
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
  1 | # Changelog
  2 | 
  3 | All notable changes to this project will be documented in this file.
  4 | 
  5 | The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
  6 | and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
  7 | 
  8 | ## Unreleased
  9 | 
 10 | ## 1.1.0 - 2025-08-05
 11 | 
 12 | ## Changed
 13 | 
 14 | - Updated pagination with tests
 15 | - Updated dependencies
 16 | - Updated openapi
 17 | 
 18 | ## 1.0.6 - 2025-07-03
 19 | 
 20 | ## Changed
 21 | 
 22 | - blockfrost-openapi 0.1.75
 23 | 
 24 | ## Added
 25 | 
 26 | - Posibility to change the base url
 27 | 
 28 | ## 1.0.5 - 2025-11-20
 29 | 
 30 | ## Fixed
 31 | 
 32 | - Readme version
 33 | 
 34 | ## 1.0.4 - 2023-11-20
 35 | 
 36 | ## Fixed
 37 | 
 38 | - Off-by-one when using Pagination::all(). Thanks [SupernaviX](https://github.com/SupernaviX) 💖
 39 | 
 40 | ## Added
 41 | 
 42 | - Transactions cbor by @SupernaviX in https://github.com/blockfrost/blockfrost-rust/pull/51
 43 | 
 44 | ## Changed
 45 | 
 46 | - Rate limit handling by @SupernaviX in https://github.com/blockfrost/blockfrost-rust/pull/52
 47 | 
 48 | ## 1.0.3 - 2023-10-05
 49 | 
 50 | ### Changed
 51 | 
 52 | - Updated dependencies to latest versions.
 53 | 
 54 | ## 1.0.2 - 2023-05-31
 55 | 
 56 | ### Added
 57 | 
 58 | - Added `derive_address` and `utils_tx_evaluate` endpoints.
 59 | 
 60 | ## 1.0.1 - 2023-01-01
 61 | 
 62 | ### Fixed
 63 | 
 64 | - Return types for asset and tx endpoints
 65 | 
 66 | ## 1.0.0 - 2023-12-18
 67 | 
 68 | ### Changed
 69 | 
 70 | - Implemented pagination for each endpoint.
 71 | - Integrated GitHub Continuous Integration for automated testing and deployment.
 72 | - Applied Cargo Clippy and rustfmt for code linting and formatting.
 73 | - Removed macros.
 74 | - Expanded test coverage with additional tests.
 75 | - Enhanced data fetching methods.
 76 | - Conducted code cleanup and refactoring.
 77 | - Refactored settings for improved clarity and efficiency.
 78 | - Updated data structures and schemas to the latest standards.
 79 | - Provided more comprehensive examples for better user understanding.
 80 | - Enhanced unit tests for more robust code testing.
 81 | - Implemented additional linting measures for code quality assurance.
 82 | - ENDPOINTS.md now contains a table of implemented endpoints.
 83 | - Added missing endpoints:
 84 |   - `accounts_addresses_total`
 85 |   - `addresses_extended`
 86 |   - `addresses_utxos_asset`
 87 |   - `network_eras`
 88 |   - `mempool`
 89 |   - `mempool_hash`
 90 |   - `mempool_addresses_address`
 91 |   - `scripts_hash_json`
 92 |   - `scripts_hash_cbor`
 93 |   - `scripts_datum_hash`
 94 |   - `scripts_datum_hash_cbor`
 95 |   - `utils_tx_evaluate`
 96 |   - `utils_tx_evaluate_utxos`
 97 | 
 98 | ## 0.2.1 - 2023-05-02
 99 | 
100 | ### Changed
101 | 
102 | `use_previewnet` -> `use_preview`
103 | `use_preprodnet` -> `use_preprod`
104 | 
105 | ### Fixed
106 | 
107 | redemeers -> redeemers
108 | 


--------------------------------------------------------------------------------
/src/api/endpoints/scripts.rs:
--------------------------------------------------------------------------------
 1 | use crate::*;
 2 | use blockfrost_openapi::models::{
 3 |     script::Script, script_redeemers_inner::ScriptRedeemersInner, scripts_inner::ScriptsInner,
 4 | };
 5 | 
 6 | impl BlockfrostAPI {
 7 |     pub async fn scripts(&self, pagination: Pagination) -> BlockfrostResult<Vec<ScriptsInner>> {
 8 |         self.call_paged_endpoint("/scripts", pagination).await
 9 |     }
10 | 
11 |     pub async fn scripts_by_id(&self, script_hash: &str) -> BlockfrostResult<Script> {
12 |         self.call_endpoint(format!("/scripts/{script_hash}").as_str())
13 |             .await
14 |     }
15 | 
16 |     pub async fn scripts_hash_json(&self, script_hash: &str) -> BlockfrostResult<ScriptsInner> {
17 |         self.call_endpoint(format!("/scripts/{script_hash}/json").as_str())
18 |             .await
19 |     }
20 | 
21 |     pub async fn scripts_hash_cbor(&self, script_hash: &str) -> BlockfrostResult<ScriptsInner> {
22 |         self.call_endpoint(format!("/scripts/{script_hash}/cbor").as_str())
23 |             .await
24 |     }
25 | 
26 |     pub async fn scripts_redeemers(
27 |         &self, script_hash: &str, pagination: Pagination,
28 |     ) -> BlockfrostResult<Vec<ScriptRedeemersInner>> {
29 |         self.call_paged_endpoint(
30 |             format!("/scripts/{script_hash}/redeemers").as_str(),
31 |             pagination,
32 |         )
33 |         .await
34 |     }
35 | 
36 |     pub async fn scripts_datum_hash(
37 |         &self, datum_hash: &str,
38 |     ) -> BlockfrostResult<serde_json::Value> {
39 |         self.call_endpoint(format!("/scripts/datum/{datum_hash}").as_str())
40 |             .await
41 |     }
42 | 
43 |     pub async fn scripts_datum_hash_cbor(
44 |         &self, datum_hash: &str,
45 |     ) -> BlockfrostResult<serde_json::Value> {
46 |         self.call_endpoint(format!("/scripts/{datum_hash}/cbor").as_str())
47 |             .await
48 |     }
49 | }
50 | 
51 | #[cfg(test)]
52 | mod tests {
53 |     use super::*;
54 |     use serde_json::json;
55 | 
56 |     #[tokio::test]
57 |     async fn test_scripts() {
58 |         let json_value = json!([
59 |             {
60 |                 "script_hash": "13a3efd825703a352a8f71f4e2758d08c28c564e8dfcce9f77776ad1"
61 |             },
62 |             {
63 |                 "script_hash": "e1457a0c47dfb7a2f6b8fbb059bdceab163c05d34f195b87b9f2b30e"
64 |             },
65 |             {
66 |                 "script_hash": "a6e63c0ff05c96943d1cc30bf53112ffff0f34b45986021ca058ec54"
67 |             }
68 |         ]);
69 |         serde_json::from_value::<Vec<ScriptsInner>>(json_value).unwrap();
70 |     }
71 | 
72 |     #[tokio::test]
73 |     async fn test_scripts_by_id() {
74 |         let json_value = json!({
75 |             "script_hash": "13a3efd825703a352a8f71f4e2758d08c28c564e8dfcce9f77776ad1",
76 |             "type": "plutusV1",
77 |             "serialised_size": 3119
78 |         });
79 |         serde_json::from_value::<Script>(json_value).unwrap();
80 |     }
81 | 
82 |     #[tokio::test]
83 |     async fn test_scripts_redeemers() {
84 |         let json_value = json!([
85 |             {
86 |                 "tx_hash": "1a0570af966fb355a7160e4f82d5a80b8681b7955f5d44bec0dce628516157f0",
87 |                 "tx_index": 0,
88 |                 "redeemer_data_hash": "2a0570af966fb355a7160e4f82d5a80b8681b7955f5d44bec0dce628516157f0",
89 |                 "purpose": "spend",
90 |                 "datum_hash": "3a0570af966fb355a7160e4f82d5a80b8681b7955f5d44bec0dce628516157f0",
91 |                 "unit_mem": "1700",
92 |                 "unit_steps": "476468",
93 |                 "fee": "172033"
94 |             }
95 |         ]);
96 |         serde_json::from_value::<Vec<ScriptRedeemersInner>>(json_value).unwrap();
97 |     }
98 | }
99 | 


--------------------------------------------------------------------------------
/src/api/endpoints/nutlink.rs:
--------------------------------------------------------------------------------
  1 | use crate::*;
  2 | use blockfrost_openapi::models::{
  3 |     nutlink_address::NutlinkAddress, nutlink_address_ticker_inner::NutlinkAddressTickerInner,
  4 |     nutlink_address_tickers_inner::NutlinkAddressTickersInner,
  5 |     nutlink_tickers_ticker_inner::NutlinkTickersTickerInner,
  6 | };
  7 | 
  8 | impl BlockfrostAPI {
  9 |     pub async fn nutlink_address(&self, address: &str) -> BlockfrostResult<NutlinkAddress> {
 10 |         self.call_endpoint(format!("/nutlink/{address}").as_str())
 11 |             .await
 12 |     }
 13 | 
 14 |     pub async fn nutlink_address_tickers(
 15 |         &self, address: &str, pagination: Pagination,
 16 |     ) -> BlockfrostResult<Vec<NutlinkAddressTickersInner>> {
 17 |         self.call_paged_endpoint(format!("/nutlink/{address}/tickers").as_str(), pagination)
 18 |             .await
 19 |     }
 20 | 
 21 |     pub async fn nutlink_address_ticker_by_id(
 22 |         &self, address: &str, ticker: &str, pagination: Pagination,
 23 |     ) -> BlockfrostResult<Vec<NutlinkAddressTickerInner>> {
 24 |         self.call_paged_endpoint(
 25 |             format!("/nutlink/{address}/tickers/{ticker}").as_str(),
 26 |             pagination,
 27 |         )
 28 |         .await
 29 |     }
 30 | 
 31 |     pub async fn nutlink_ticker_by_id(
 32 |         &self, ticker: &str, pagination: Pagination,
 33 |     ) -> BlockfrostResult<Vec<NutlinkTickersTickerInner>> {
 34 |         self.call_paged_endpoint(format!("/nutlink/tickers/{ticker}").as_str(), pagination)
 35 |             .await
 36 |     }
 37 | }
 38 | 
 39 | #[cfg(test)]
 40 | mod tests {
 41 |     use super::*;
 42 |     use blockfrost_openapi::models::nutlink_address_tickers_inner::NutlinkAddressTickersInner;
 43 |     use serde_json::json;
 44 | 
 45 |     #[tokio::test]
 46 |     async fn test_nutlink_address() {
 47 |         let json_value = json!({
 48 |             "address": "addr1qxqs59lphg8g6qndelq8xwqn60ag3aeyfcp33c2kdp46a09re5df3pzwwmyq946axfcejy5n4x0y99wqpgtp2gd0k09qsgy6pz",
 49 |             "metadata_url": "https://nut.link/metadata.json",
 50 |             "metadata_hash": "6bf124f217d0e5a0a8adb1dbd8540e1334280d49ab861127868339f43b3948af",
 51 |             "metadata": {}
 52 |         });
 53 | 
 54 |         serde_json::from_value::<NutlinkAddress>(json_value).unwrap();
 55 |     }
 56 | 
 57 |     #[tokio::test]
 58 |     async fn test_nutlink_address_tickers() {
 59 |         let json_value = json!([
 60 |             {
 61 |                 "name": "ADAUSD",
 62 |                 "count": 1980038,
 63 |                 "latest_block": 2657092
 64 |             },
 65 |             {
 66 |                 "name": "ADAEUR",
 67 |                 "count": 1980038,
 68 |                 "latest_block": 2657092
 69 |             },
 70 |             {
 71 |                 "name": "ADABTC",
 72 |                 "count": 1980038,
 73 |                 "latest_block": 2657092
 74 |             }
 75 |         ]);
 76 | 
 77 |         serde_json::from_value::<Vec<NutlinkAddressTickersInner>>(json_value).unwrap();
 78 |     }
 79 | 
 80 |     #[tokio::test]
 81 |     async fn test_nutlink_address_ticker_detailed() {
 82 |         let json_value = json!([
 83 |             {
 84 |                 "tx_hash": "e8073fd5318ff43eca18a852527166aa8008bee9ee9e891f585612b7e4ba700b",
 85 |                 "block_height": 2657092,
 86 |                 "tx_index": 8,
 87 |                 "payload": [
 88 |                     {
 89 |                         "source": "coinGecko",
 90 |                         "value": "1.29"
 91 |                     },
 92 |                     {
 93 |                         "source": "cryptoCompare",
 94 |                         "value": "1.283"
 95 |                     }
 96 |                 ]
 97 |             }
 98 |         ]);
 99 | 
100 |         serde_json::from_value::<Vec<NutlinkAddressTickerInner>>(json_value).unwrap();
101 |     }
102 | }
103 | 


--------------------------------------------------------------------------------
/ENDPOINTS.md:
--------------------------------------------------------------------------------
  1 | # Endpoints
  2 | 
  3 | - Health
  4 |   - [x] `GET /`
  5 |   - [x] `GET /health`
  6 |   - [x] `GET /health/clock`
  7 | - Metrics
  8 |   - [x] `GET /metrics`
  9 |   - [x] `GET /metrics/endpoints`
 10 | - Accounts
 11 |   - [x] `GET /accounts/:stake_address`
 12 |   - [x] `GET /accounts/:stake_address/rewards`
 13 |   - [x] `GET /accounts/:stake_address/history`
 14 |   - [x] `GET /accounts/:stake_address/delegations`
 15 |   - [x] `GET /accounts/:stake_address/registrations`
 16 |   - [x] `GET /accounts/:stake_address/withdrawals`
 17 |   - [x] `GET /accounts/:stake_address/mirs`
 18 |   - [x] `GET /accounts/:stake_address/addresses`
 19 |   - [x] `GET /accounts/:stake_address/addresses/assets`
 20 |   - [x] `GET /accounts/:stake_address/addresses/total`
 21 | - Addresses
 22 |   - [x] `GET /addresses/:address`
 23 |   - [x] `GET /addresses/:address/extended`
 24 |   - [x] `GET /addresses/:address/total`
 25 |   - [x] `GET /addresses/:address/utxos`
 26 |   - [x] `GET /addresses/:address/utxos/:asset`
 27 |   - [x] `GET /addresses/:address/transactions`
 28 | - Assets
 29 |   - [x] `GET /assets`
 30 |   - [x] `GET /assets/:asset`
 31 |   - [x] `GET /assets/:asset/history`
 32 |   - [x] `GET /assets/:asset/transactions`
 33 |   - [x] `GET /assets/:asset/addresses`
 34 |   - [x] `GET /assets/policy/:policy_id`
 35 | - Blocks
 36 |   - [x] `GET /blocks/latest`
 37 |   - [x] `GET /blocks/latest/txs`
 38 |   - [x] `GET /blocks/:hash_or_number`
 39 |   - [x] `GET /blocks/:hash_or_number/next`
 40 |   - [x] `GET /blocks/:hash_or_number/previous`
 41 |   - [x] `GET /blocks/slot/:slot_number`
 42 |   - [x] `GET /blocks/epoch/:epoch_number/slot/:slot_number`
 43 |   - [x] `GET /blocks/:hash_or_number/txs`
 44 |   - [x] `GET /blocks/:hash_or_number/addresses`
 45 | - Epochs
 46 |   - [x] `GET /epochs/latest`
 47 |   - [x] `GET /epochs/latest/parameters`
 48 |   - [x] `GET /epochs/:number`
 49 |   - [x] `GET /epochs/:number/next`
 50 |   - [x] `GET /epochs/:number/previous`
 51 |   - [x] `GET /epochs/:number/stakes`
 52 |   - [x] `GET /epochs/:number/stakes/:pool_id`
 53 |   - [x] `GET /epochs/:number/stakes/blocks`
 54 |   - [x] `GET /epochs/:number/stakes/blocks/:pool_id`
 55 |   - [x] `GET /epochs/:number/parameters`
 56 | - Ledger
 57 |   - [x] `GET /genesis`
 58 | - Mempool
 59 |   - [x] `GET /mempool`
 60 |   - [x] `GET /mempool/:hash`
 61 |   - [x] `GET /mempool/addresses/:address`
 62 | - Metadata
 63 |   - [x] `GET /metadata/txs/labels`
 64 |   - [x] `GET /metadata/txs/labels/:label`
 65 |   - [x] `GET /metadata/txs/labels/:label/cbor`
 66 | - Network
 67 |   - [x] `GET /network`
 68 |   - [x] `GET /network/eras`
 69 | - Pools
 70 |   - [x] `GET /pools`
 71 |   - [x] `GET /pools/extended`
 72 |   - [x] `GET /pools/retired`
 73 |   - [x] `GET /pools/retiring`
 74 |   - [x] `GET /pools/:pool_id`
 75 |   - [x] `GET /pools/:pool_id/history`
 76 |   - [x] `GET /pools/:pool_id/metadata`
 77 |   - [x] `GET /pools/:pool_id/relays`
 78 |   - [x] `GET /pools/:pool_id/delegators`
 79 |   - [x] `GET /pools/:pool_id/blocks`
 80 |   - [x] `GET /pools/:pool_id/updates`
 81 | - Scripts
 82 |   - [x] `GET /scripts`
 83 |   - [x] `GET /scripts/:hash`
 84 |   - [x] `GET /scripts/:hash/json`
 85 |   - [x] `GET /scripts/:hash/cbor`
 86 |   - [x] `GET /scripts/:script_hash/redeemers`
 87 |   - [x] `GET /scripts/datum/:datum_hash`
 88 |   - [x] `GET /scripts/datum/:datum_hash/cbor`
 89 | - Transactions
 90 |   - [x] `GET /txs/:hash`
 91 |   - [x] `GET /txs/:hash/utxos`
 92 |   - [x] `GET /txs/:hash/stakes`
 93 |   - [x] `GET /txs/:hash/delegations`
 94 |   - [x] `GET /txs/:hash/withdrawals`
 95 |   - [x] `GET /txs/:hash/mirs`
 96 |   - [x] `GET /txs/:hash/pool_updates`
 97 |   - [x] `GET /txs/:hash/pool_retires`
 98 |   - [x] `GET /txs/:hash/metadata`
 99 |   - [x] `GET /txs/:hash/metadata/cbor`
100 |   - [x] `GET /txs/:hash/redeemers`
101 |   - [x] `POST /tx/submit`
102 | - Utils
103 |   - [x] `GET /utils/addresses/xpub/:xpub/:role/:index`
104 |   - [x] `POST /utils/txs/evaluate`
105 |   - [] `POST /utils/txs/evaluate/utxos`
106 | 


--------------------------------------------------------------------------------
/src/error.rs:
--------------------------------------------------------------------------------
  1 | use crate::utils;
  2 | use reqwest::StatusCode;
  3 | use serde::{Deserialize, Serialize};
  4 | use serde_json::from_str;
  5 | use thiserror::Error;
  6 | use {reqwest::Error as ReqwestError, serde_json::Error as SerdeJsonError};
  7 | 
  8 | pub type BlockfrostResult<T, E = BlockfrostError> = std::result::Result<T, E>;
  9 | 
 10 | #[derive(Error, Debug)]
 11 | pub enum BlockfrostError {
 12 |     #[error("Reqwest error for URL {url}: {reason}")]
 13 |     Reqwest { url: String, reason: reqwest::Error },
 14 |     #[error("JSON error for URL {url}: {reason}\nText: '{text}'")]
 15 |     Json {
 16 |         url: String,
 17 |         text: String,
 18 |         reason: serde_json::Error,
 19 |     },
 20 |     #[error("Parsing error: {message}")]
 21 |     Parsing { message: String },
 22 |     #[error("IO error: {0}")]
 23 |     Io(#[from] std::io::Error),
 24 |     #[error("Response error for URL {url}: {reason}")]
 25 |     Response { url: String, reason: ResponseError },
 26 | }
 27 | 
 28 | #[derive(Serialize, Deserialize, Error, Debug, Clone)]
 29 | pub struct ResponseError {
 30 |     pub status_code: u16,
 31 |     pub error: String,
 32 |     pub message: String,
 33 | }
 34 | 
 35 | impl std::fmt::Display for ResponseError {
 36 |     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
 37 |         writeln!(f, "Status code: {}", self.status_code)?;
 38 |         writeln!(f, "Error: {}", self.error)?;
 39 |         write!(f, "Message: {}", self.message)
 40 |     }
 41 | }
 42 | 
 43 | // Parsing the error response is tricky, it's necessary to check if the json body is
 44 | // malformed, if so, we will catch an error trying to get the cause to another error
 45 | //
 46 | // Catching a Error::Json when trying to interpret a Error::ErrorResponse
 47 | //
 48 | // This function can only return Error::ErrorResponse.
 49 | pub(crate) fn process_error_response(
 50 |     text: &str, status_code: StatusCode, url: &str,
 51 | ) -> BlockfrostError {
 52 |     let status_code = status_code.as_u16();
 53 | 
 54 |     let expected_error_codes = &[400, 403, 404, 418, 429, 500];
 55 |     if !expected_error_codes.contains(&status_code) {
 56 |         eprintln!("Warning: status code {status_code} was not expected.");
 57 |     }
 58 |     let url = url.into();
 59 | 
 60 |     match from_str::<ResponseError>(text) {
 61 |         Ok(http_error) => BlockfrostError::Response {
 62 |             reason: http_error,
 63 |             url,
 64 |         },
 65 |         Err(_) => {
 66 |             // Try to format JSON body, or use unformatted body instead
 67 |             let formatted_body_text =
 68 |                 utils::try_formatting_json(text).unwrap_or_else(|_| text.to_owned());
 69 |             let reason = "Could not parse error body to interpret the reason of the error".into();
 70 | 
 71 |             let http_error = ResponseError {
 72 |                 status_code,
 73 |                 error: reason,
 74 |                 message: formatted_body_text,
 75 |             };
 76 |             BlockfrostError::Response {
 77 |                 reason: http_error,
 78 |                 url,
 79 |             }
 80 |         }
 81 |     }
 82 | }
 83 | 
 84 | impl From<Box<dyn std::error::Error>> for BlockfrostError {
 85 |     fn from(e: Box<dyn std::error::Error>) -> Self {
 86 |         BlockfrostError::Parsing {
 87 |             message: e.to_string(),
 88 |         }
 89 |     }
 90 | }
 91 | 
 92 | // Helper to create a Error::Reqwest
 93 | pub(crate) fn reqwest_error(url: impl ToString, error: ReqwestError) -> BlockfrostError {
 94 |     BlockfrostError::Reqwest {
 95 |         url: url.to_string(),
 96 |         reason: error,
 97 |     }
 98 | }
 99 | 
100 | // Helper to create a Error::Json
101 | pub(crate) fn json_error(
102 |     url: impl ToString, text: impl ToString, error: SerdeJsonError,
103 | ) -> BlockfrostError {
104 |     BlockfrostError::Json {
105 |         url: url.to_string(),
106 |         text: text.to_string(),
107 |         reason: error,
108 |     }
109 | }
110 | 


--------------------------------------------------------------------------------
/src/api/endpoints/metadata.rs:
--------------------------------------------------------------------------------
  1 | use crate::*;
  2 | use blockfrost_openapi::models::{
  3 |     tx_metadata_label_cbor_inner::TxMetadataLabelCborInner,
  4 |     tx_metadata_label_json_inner::TxMetadataLabelJsonInner,
  5 |     tx_metadata_labels_inner::TxMetadataLabelsInner,
  6 | };
  7 | 
  8 | impl BlockfrostAPI {
  9 |     /// List of all used transaction metadata labels.
 10 |     pub async fn metadata_txs_labels(
 11 |         &self, pagination: Pagination,
 12 |     ) -> BlockfrostResult<Vec<TxMetadataLabelsInner>> {
 13 |         self.call_paged_endpoint("/metadata/txs/labels", pagination)
 14 |             .await
 15 |     }
 16 | 
 17 |     /// Transaction metadata per label (json).
 18 |     pub async fn metadata_txs_by_label(
 19 |         &self, label: &str, pagination: Pagination,
 20 |     ) -> BlockfrostResult<Vec<TxMetadataLabelJsonInner>> {
 21 |         self.call_paged_endpoint(format!("/metadata/txs/labels/{label}").as_str(), pagination)
 22 |             .await
 23 |     }
 24 | 
 25 |     /// Transaction metadata per label (cbor).
 26 |     pub async fn metadata_txs_by_label_cbor(
 27 |         &self, label: &str, pagination: Pagination,
 28 |     ) -> BlockfrostResult<Vec<TxMetadataLabelCborInner>> {
 29 |         self.call_paged_endpoint(
 30 |             format!("/metadata/txs/labels/{label}/cbor").as_str(),
 31 |             pagination,
 32 |         )
 33 |         .await
 34 |     }
 35 | }
 36 | 
 37 | #[cfg(test)]
 38 | mod tests {
 39 |     use blockfrost_openapi::models::{
 40 |         tx_metadata_label_cbor_inner::TxMetadataLabelCborInner,
 41 |         tx_metadata_label_json_inner::TxMetadataLabelJsonInner,
 42 |         tx_metadata_labels_inner::TxMetadataLabelsInner,
 43 |     };
 44 |     use serde_json::json;
 45 | 
 46 |     #[test]
 47 |     fn test_metadata_txs_labels() {
 48 |         let json_value = json!([
 49 |           {
 50 |             "label": "1990",
 51 |             "cip10": null,
 52 |             "count": "1"
 53 |           },
 54 |           {
 55 |             "label": "1967",
 56 |             "cip10": "nut.link metadata oracles registry",
 57 |             "count": "3"
 58 |           },
 59 |           {
 60 |             "label": "1968",
 61 |             "cip10": "nut.link metadata oracles data points",
 62 |             "count": "16321"
 63 |           }
 64 |         ]);
 65 | 
 66 |         serde_json::from_value::<Vec<TxMetadataLabelsInner>>(json_value).unwrap();
 67 |     }
 68 | 
 69 |     #[test]
 70 |     fn test_metadata_txs_by_label() {
 71 |         let json_value = json!([
 72 |           {
 73 |             "tx_hash": "257d75c8ddb0434e9b63e29ebb6241add2b835a307aa33aedba2effe09ed4ec8",
 74 |             "json_metadata": {
 75 |               "ADAUSD": [
 76 |                 {
 77 |                   "value": "0.10409800535729975",
 78 |                   "source": "ergoOracles"
 79 |                 }
 80 |               ]
 81 |             }
 82 |           },
 83 |           {
 84 |             "tx_hash": "e865f2cc01ca7381cf98dcdc4de07a5e8674b8ea16e6a18e3ed60c186fde2b9c",
 85 |             "json_metadata": {
 86 |               "ADAUSD": [
 87 |                 {
 88 |                   "value": "0.15409850555139935",
 89 |                   "source": "ergoOracles"
 90 |                 }
 91 |               ]
 92 |             }
 93 |           },
 94 |           {
 95 |             "tx_hash": "4237501da3cfdd53ade91e8911e764bd0699d88fd43b12f44a1f459b89bc91be",
 96 |             "json_metadata": null
 97 |           },
 98 |           {
 99 |             "tx_hash": "19e20c46fd73dc483fd45aee7e8df0a88917ac404143b63787bd39f535bdbb96",
100 |             "json_metadata": [
101 |               {
102 |                 "eng": {
103 |                   "content": [
104 |                     "For more information, visit our website www.stakenuts.com."
105 |                   ],
106 |                   "title": "Welcome to NUTS!"
107 |                 }
108 |               }
109 |             ],
110 |           }
111 |         ]);
112 | 
113 |         serde_json::from_value::<Vec<TxMetadataLabelJsonInner>>(json_value).unwrap();
114 |     }
115 | 
116 |     #[test]
117 |     fn test_test_metadata_txs_labels() {
118 |         let json_value = json!([
119 |           {
120 |             "label": "1990",
121 |             "cip10": null,
122 |             "count": "1"
123 |           },
124 |           {
125 |             "label": "1967",
126 |             "cip10": "nut.link metadata oracles registry",
127 |             "count": "3"
128 |           },
129 |           {
130 |             "label": "1968",
131 |             "cip10": "nut.link metadata oracles data points",
132 |             "count": "16321"
133 |           }
134 |         ]);
135 | 
136 |         serde_json::from_value::<Vec<TxMetadataLabelsInner>>(json_value).unwrap();
137 |     }
138 | 
139 |     #[test]
140 |     fn test_metadata_txs_by_label_cbor() {
141 |         let json_value = json!([
142 |           {
143 |             "tx_hash": "257d75c8ddb0434e9b63e29ebb6241add2b835a307aa33aedba2effe09ed4ec8",
144 |             "cbor_metadata": null,
145 |             "metadata": null
146 |           },
147 |           {
148 |             "tx_hash": "e865f2cc01ca7381cf98dcdc4de07a5e8674b8ea16e6a18e3ed60c186fde2b9c",
149 |             "cbor_metadata": null,
150 |             "metadata": null
151 |           },
152 |           {
153 |             "tx_hash": "4237501da3cfdd53ade91e8911e764bd0699d88fd43b12f44a1f459b89bc91be",
154 |             "cbor_metadata": "\\xa100a16b436f6d62696e6174696f6e8601010101010c",
155 |             "metadata": null
156 |           }
157 |         ]);
158 | 
159 |         serde_json::from_value::<Vec<TxMetadataLabelCborInner>>(json_value).unwrap();
160 |     }
161 | }
162 | 


--------------------------------------------------------------------------------
/src/api/endpoints/blocks.rs:
--------------------------------------------------------------------------------
  1 | use crate::*;
  2 | use blockfrost_openapi::models::{
  3 |     block_content::BlockContent, block_content_addresses_inner::BlockContentAddressesInner,
  4 | };
  5 | 
  6 | impl BlockfrostAPI {
  7 |     pub async fn blocks_latest(&self) -> BlockfrostResult<BlockContent> {
  8 |         self.call_endpoint("/blocks/latest").await
  9 |     }
 10 | 
 11 |     pub async fn blocks_by_id(&self, hash_or_number: &str) -> BlockfrostResult<BlockContent> {
 12 |         self.call_endpoint(format!("/blocks/{hash_or_number}").as_str())
 13 |             .await
 14 |     }
 15 | 
 16 |     pub async fn blocks_slot(&self, slot_number: i64) -> BlockfrostResult<BlockContent> {
 17 |         self.call_endpoint(format!("/blocks/slot/{slot_number}").as_str())
 18 |             .await
 19 |     }
 20 | 
 21 |     pub async fn blocks_by_epoch_and_slot(
 22 |         &self, epoch_number: i32, slot_number: i64,
 23 |     ) -> BlockfrostResult<BlockContent> {
 24 |         self.call_endpoint(format!("/blocks/epoch/{epoch_number}/slot/{slot_number}").as_str())
 25 |             .await
 26 |     }
 27 | 
 28 |     pub async fn blocks_latest_txs(&self, pagination: Pagination) -> BlockfrostResult<Vec<String>> {
 29 |         self.call_paged_endpoint("/blocks/latest/txs", pagination)
 30 |             .await
 31 |     }
 32 | 
 33 |     pub async fn blocks_next(
 34 |         &self, hash_or_number: &str, pagination: Pagination,
 35 |     ) -> BlockfrostResult<Vec<BlockContent>> {
 36 |         self.call_paged_endpoint(
 37 |             format!("/blocks/{hash_or_number}/next").as_str(),
 38 |             pagination,
 39 |         )
 40 |         .await
 41 |     }
 42 | 
 43 |     pub async fn blocks_previous(
 44 |         &self, hash_or_number: &str, pagination: Pagination,
 45 |     ) -> BlockfrostResult<Vec<BlockContent>> {
 46 |         self.call_paged_endpoint(
 47 |             format!("/blocks/{hash_or_number}/previous").as_str(),
 48 |             pagination,
 49 |         )
 50 |         .await
 51 |     }
 52 | 
 53 |     pub async fn blocks_txs(
 54 |         &self, hash_or_number: &str, pagination: Pagination,
 55 |     ) -> BlockfrostResult<Vec<String>> {
 56 |         self.call_paged_endpoint(format!("/blocks/{hash_or_number}/txs").as_str(), pagination)
 57 |             .await
 58 |     }
 59 | 
 60 |     pub async fn blocks_affected_addresses(
 61 |         &self, hash_or_number: &str, pagination: Pagination,
 62 |     ) -> BlockfrostResult<Vec<BlockContentAddressesInner>> {
 63 |         self.call_paged_endpoint(
 64 |             format!("/blocks/{hash_or_number}/addresses").as_str(),
 65 |             pagination,
 66 |         )
 67 |         .await
 68 |     }
 69 | }
 70 | 
 71 | #[cfg(test)]
 72 | mod tests {
 73 |     use blockfrost_openapi::models::block_content::BlockContent;
 74 |     use serde_json::json;
 75 | 
 76 |     #[tokio::test]
 77 |     async fn test_blocks_latest() {
 78 |         let json_value = json!({
 79 |             "time": 1641338934,
 80 |             "height": 15243593,
 81 |             "hash": "4ea1ba291e8eef538635a53e59fddba7810d1679631cc3aed7c8e6c4091a516a",
 82 |             "slot": 412162133,
 83 |             "epoch": 425,
 84 |             "epoch_slot": 12,
 85 |             "slot_leader": "pool1pu5jlj4q9w9jlxeu370a3c9myx47md5j5m2str0naunn2qnikdy",
 86 |             "size": 3,
 87 |             "tx_count": 1,
 88 |             "output": "128314491794",
 89 |             "fees": "592661",
 90 |             "block_vrf": "vrf_vk1wf2k6lhujezqcfe00l6zetxpnmh9n6mwhpmhm0dvfh3fxgmdnrfqkms8ty",
 91 |             "previous_block": "43ebccb3ac72c7cebd0d9b755a4b08412c9f5dcb81b8a0ad1e3c197d29d47b05",
 92 |             "next_block": "8367f026cf4b03e116ff8ee5daf149b55ba5a6ec6dec04803b8dc317721d15fa",
 93 |             "confirmations": 4698,
 94 |             "op_cert": null,
 95 |             "op_cert_counter": "1"
 96 |         });
 97 | 
 98 |         serde_json::from_value::<BlockContent>(json_value).unwrap();
 99 |     }
100 | 
101 |     #[tokio::test]
102 |     async fn test_blocks_latest_txs() {
103 |         let json_value = json!([
104 |             "8788591983aa73981fc92d6cddbbe643959f5a784e84b8bee0db15823f575a5b",
105 |             "4eef6bb7755d8afbeac526b799f3e32a624691d166657e9d862aaeb66682c036",
106 |             "52e748c4dec58b687b90b0b40d383b9fe1f24c1a833b7395cdf07dd67859f46f",
107 |             "e8073fd5318ff43eca18a852527166aa8008bee9ee9e891f585612b7e4ba700b"
108 |         ]);
109 | 
110 |         serde_json::from_value::<Vec<String>>(json_value).unwrap();
111 |     }
112 | 
113 |     #[tokio::test]
114 |     async fn test_blocks_next() {
115 |         let json_value = json!([{
116 |             "time": 1641338934,
117 |             "height": 15243593,
118 |             "hash": "4ea1ba291e8eef538635a53e59fddba7810d1679631cc3aed7c8e6c4091a516a",
119 |             "slot": 412162133,
120 |             "epoch": 425,
121 |             "epoch_slot": 12,
122 |             "slot_leader": "pool1pu5jlj4q9w9jlxeu370a3c9myx47md5j5m2str0naunn2qnikdy",
123 |             "size": 3,
124 |             "tx_count": 1,
125 |             "output": "128314491794",
126 |             "fees": "592661",
127 |             "block_vrf": "vrf_vk1wf2k6lhujezqcfe00l6zetxpnmh9n6mwhpmhm0dvfh3fxgmdnrfqkms8ty",
128 |             "previous_block": "43ebccb3ac72c7cebd0d9b755a4b08412c9f5dcb81b8a0ad1e3c197d29d47b05",
129 |             "next_block": "8367f026cf4b03e116ff8ee5daf149b55ba5a6ec6dec04803b8dc317721d15fa",
130 |             "confirmations": 46982,
131 |             "op_cert_counter": "1",
132 |             "op_cert": null
133 |         }]);
134 | 
135 |         serde_json::from_value::<Vec<BlockContent>>(json_value).unwrap();
136 |     }
137 | 
138 |     #[tokio::test]
139 |     async fn test_blocks_txs() {
140 |         let json_value = json!([
141 |             "8788591983aa73981fc92d6cddbbe643959f5a784e84b8bee0db15823f575a5b",
142 |             "4eef6bb7755d8afbeac526b799f3e32a624691d166657e9d862aaeb66682c036",
143 |             "52e748c4dec58b687b90b0b40d383b9fe1f24c1a833b7395cdf07dd67859f46f",
144 |             "e8073fd5318ff43eca18a852527166aa8008bee9ee9e891f585612b7e4ba700b"
145 |         ]);
146 | 
147 |         serde_json::from_value::<Vec<String>>(json_value).unwrap();
148 |     }
149 | }
150 | 


--------------------------------------------------------------------------------
/src/api/endpoints/assets.rs:
--------------------------------------------------------------------------------
  1 | use crate::*;
  2 | use blockfrost_openapi::models::{
  3 |     asset::Asset, asset_addresses_inner::AssetAddressesInner,
  4 |     asset_history_inner::AssetHistoryInner, asset_policy_inner::AssetPolicyInner,
  5 |     asset_transactions_inner::AssetTransactionsInner, assets_inner::AssetsInner,
  6 | };
  7 | 
  8 | impl BlockfrostAPI {
  9 |     pub async fn assets_by_id(&self, asset: &str) -> BlockfrostResult<Asset> {
 10 |         self.call_endpoint(format!("/assets/{asset}").as_str())
 11 |             .await
 12 |     }
 13 | 
 14 |     pub async fn assets(&self, pagination: Pagination) -> BlockfrostResult<Vec<AssetsInner>> {
 15 |         self.call_paged_endpoint("/assets", pagination).await
 16 |     }
 17 | 
 18 |     pub async fn assets_history(
 19 |         &self, asset: &str, pagination: Pagination,
 20 |     ) -> BlockfrostResult<Vec<AssetHistoryInner>> {
 21 |         self.call_paged_endpoint(format!("/assets/{asset}/history").as_str(), pagination)
 22 |             .await
 23 |     }
 24 | 
 25 |     pub async fn assets_transactions(
 26 |         &self, asset: &str, pagination: Pagination,
 27 |     ) -> BlockfrostResult<Vec<AssetTransactionsInner>> {
 28 |         self.call_paged_endpoint(format!("/assets/{asset}/transactions").as_str(), pagination)
 29 |             .await
 30 |     }
 31 | 
 32 |     pub async fn assets_addresses(
 33 |         &self, asset: &str, pagination: Pagination,
 34 |     ) -> BlockfrostResult<Vec<AssetAddressesInner>> {
 35 |         self.call_paged_endpoint(format!("/assets/{asset}/addresses").as_str(), pagination)
 36 |             .await
 37 |     }
 38 | 
 39 |     pub async fn assets_policy_by_id(
 40 |         &self, policy_id: &str, pagination: Pagination,
 41 |     ) -> BlockfrostResult<Vec<AssetPolicyInner>> {
 42 |         self.call_paged_endpoint(format!("/assets/policy/{policy_id}").as_str(), pagination)
 43 |             .await
 44 |     }
 45 | }
 46 | 
 47 | #[cfg(test)]
 48 | mod tests {
 49 |     use super::*;
 50 |     use blockfrost_openapi::models::{
 51 |         asset::Asset, asset_transactions_inner::AssetTransactionsInner, assets_inner::AssetsInner,
 52 |     };
 53 |     use serde_json::json;
 54 | 
 55 |     #[tokio::test]
 56 |     async fn test_asset() {
 57 |         let json_value = json!([
 58 |             {
 59 |                 "asset": "b0d07d45fe9514f80213f4020e5a61241458be626841cde717cb38a76e7574636f696e",
 60 |                 "quantity": "1"
 61 |             },
 62 |             {
 63 |                 "asset": "b0d07d45fe9514f80213f4020e5a61241458be626841cde717cb38a76e75d",
 64 |                 "quantity": "100000"
 65 |             },
 66 |             {
 67 |                 "asset": "6804edf9712d2b619edb6ac86861fe93a730693183a262b165fcc1ba1bc99cad",
 68 |                 "quantity": "18605647"
 69 |             }
 70 |         ]);
 71 | 
 72 |         serde_json::from_value::<Vec<AssetsInner>>(json_value).unwrap();
 73 |     }
 74 | 
 75 |     #[tokio::test]
 76 |     async fn test_asset_details() {
 77 |         let json_value = json!({
 78 |             "asset": "b0d07d45fe9514f80213f4020e5a61241458be626841cde717cb38a76e7574636f696e",
 79 |             "policy_id": "b0d07d45fe9514f80213f4020e5a61241458be626841cde717cb38a7",
 80 |             "asset_name": "6e7574636f696e",
 81 |             "fingerprint": "asset1pkpwyknlvul7az0xx8czhl60pyel45rpje4z8w",
 82 |             "quantity": "12000",
 83 |             "initial_mint_tx_hash": "6804edf9712d2b619edb6ac86861fe93a730693183a262b165fcc1ba1bc99cad",
 84 |             "mint_or_burn_count": 1,
 85 |             "onchain_metadata": {
 86 |                 "name": "My NFT token",
 87 |                 "image": "ipfs://ipfs/QmfKyJ4tuvHowwKQCbCHj4L5T3fSj8cjs7Aau8V7BWv226",
 88 |                 "additional_field": "anything"
 89 |             },
 90 |             "metadata": {
 91 |                 "name": "nutcoin",
 92 |                 "description": "The Nut Coin",
 93 |                 "ticker": "nutc",
 94 |                 "url": "https://www.stakenuts.com/",
 95 |                 "logo": "iVBORw0KGgoAAAAAAABGdBTUEAALGPC/xhBQAAAAAASUVORK5CYII=",
 96 |                 "decimals": 6
 97 |             }
 98 |         });
 99 | 
100 |         serde_json::from_value::<Asset>(json_value).unwrap();
101 |     }
102 | 
103 |     #[tokio::test]
104 |     async fn test_asset_history() {
105 |         let json_value = json!([
106 |             {
107 |                 "tx_hash": "2dd15e0ef6e6a17841cb9541c27724072ce4d4b79b91e58432fbaa32d9572531",
108 |                 "amount": "10",
109 |                 "action": "minted"
110 |             },
111 |             {
112 |                 "tx_hash": "9c190bc1ac88b2ab0c05a82d7de8b71b67a9316377e865748a89d4426c0d3005",
113 |                 "amount": "5",
114 |                 "action": "burned"
115 |             },
116 |             {
117 |                 "tx_hash": "1a0570af966fb355a7160e4f82d5a80b8681b7955f5d44bec0dde628516157f0",
118 |                 "amount": "5",
119 |                 "action": "burned"
120 |             }
121 |         ]);
122 | 
123 |         serde_json::from_value::<Vec<AssetHistoryInner>>(json_value).unwrap();
124 |     }
125 | 
126 |     #[tokio::test]
127 |     async fn test_asset_transaction() {
128 |         let json_value = json!([
129 |             {
130 |                 "tx_hash": "8788591983aa73981fc92d6cddbbe643959f5a784e84b8bee0db15823f575a5b",
131 |                 "tx_index": 6,
132 |                 "block_height": 69,
133 |                 "block_time": 13
134 |             },
135 |             {
136 |                 "tx_hash": "52e748c4dec58b687b90b0b40d383b9fe1f24c1a833b7395cdf07dd67859f46f",
137 |                 "tx_index": 9,
138 |                 "block_height": 4547,
139 |                 "block_time": 11
140 |             },
141 |             {
142 |                 "tx_hash": "e8073fd5318ff43eca18a852527166aa8008bee9ee9e891f585612b7e4ba700b",
143 |                 "tx_index": 0,
144 |                 "block_height": 564654,
145 |                 "block_time": 12
146 |             }
147 |         ]);
148 | 
149 |         serde_json::from_value::<Vec<AssetTransactionsInner>>(json_value).unwrap();
150 |     }
151 | 
152 |     #[tokio::test]
153 |     async fn test_asset_address() {
154 |         let json_value = json!([
155 |             {
156 |                 "address": "addr1qxqs59lphg8g6qndelq8xwqn60ag3aeyfcp33c2kdp46a09re5df3pzwwmyq946axfcejy5n4x0y99wqpgtp2gd0k09qsgy6pz",
157 |                 "quantity": "1"
158 |             },
159 |             {
160 |                 "address": "addr1qyhr4exrgavdcn3qhfcc9f939fzsch2re5ry9cwvcdyh4x4re5df3pzwwmyq946axfcejy5n4x0y99wqpgtp2gd0k09qdpvhza",
161 |                 "quantity": "100000"
162 |             },
163 |             {
164 |                 "address": "addr1q8zup8m9ue3p98kxlxl9q8rnyan8hw3ul282tsl9s326dfj088lvedv4zckcj24arcpasr0gua4c5gq4zw2rpcpjk2lq8cmd9l",
165 |                 "quantity": "18605647"
166 |             }
167 |         ]);
168 | 
169 |         serde_json::from_value::<Vec<AssetAddressesInner>>(json_value).unwrap();
170 |     }
171 | 
172 |     #[tokio::test]
173 |     async fn test_asset_policy_by_id() {
174 |         let json_value = json!([
175 |             {
176 |                 "asset": "b0d07d45fe9514f80213f4020e5a61241458be626841cde717cb38a76e7574636f696e",
177 |                 "quantity": "1"
178 |             },
179 |             {
180 |                 "asset": "b0d07d45fe9514f80213f4020e5a61241458be626841cde717cb38a766e",
181 |                 "quantity": "100000"
182 |             },
183 |             {
184 |                 "asset": "b0d07d45fe9514f80213f4020e5a61241458be626841cde717cb574636f696e",
185 |                 "quantity": "18605647"
186 |             }
187 |         ]);
188 | 
189 |         serde_json::from_value::<Vec<AssetPolicyInner>>(json_value).unwrap();
190 |     }
191 | }
192 | 


--------------------------------------------------------------------------------
/src/request.rs:
--------------------------------------------------------------------------------
  1 | use crate::{
  2 |     json_error, pagination::Pagination, process_error_response, reqwest_error, url::Url,
  3 |     BlockfrostError, RetrySettings,
  4 | };
  5 | use futures::future::try_join_all;
  6 | use futures_timer::Delay;
  7 | use reqwest::{Client, RequestBuilder, Response, StatusCode};
  8 | use serde::de::DeserializeOwned;
  9 | use serde_json::from_str;
 10 | use std::future::Future;
 11 | 
 12 | // Used only for simple and common GET requests.
 13 | // Functions that require extra logic may not call this.
 14 | pub(crate) fn send_get_request<T>(
 15 |     client: &Client, url: String, retry_settings: RetrySettings,
 16 | ) -> impl Future<Output = Result<T, BlockfrostError>> + Send
 17 | where
 18 |     T: serde::de::DeserializeOwned,
 19 | {
 20 |     let request = client.get(&url);
 21 | 
 22 |     async move {
 23 |         let (status, text) = send_request(request, retry_settings)
 24 |             .await
 25 |             .map_err(|reason| reqwest_error(&url, reason))?;
 26 | 
 27 |         if !status.is_success() {
 28 |             return Err(process_error_response(&text, status, &url));
 29 |         }
 30 | 
 31 |         from_str::<T>(&text).map_err(|reason| json_error(url, text, reason))
 32 |     }
 33 | }
 34 | 
 35 | // Send requests with delayed retries, cloning the request builder only when necessary.
 36 | pub(crate) async fn send_request_unprocessed(
 37 |     request: RequestBuilder, retry_settings: RetrySettings,
 38 | ) -> reqwest::Result<Response> {
 39 |     for _ in 1..retry_settings.amount {
 40 |         let request = clone_request(&request);
 41 |         let response = request.send().await;
 42 |         let retry_codes = [
 43 |             StatusCode::REQUEST_TIMEOUT,
 44 |             StatusCode::PAYLOAD_TOO_LARGE,
 45 |             StatusCode::TOO_MANY_REQUESTS,
 46 |             StatusCode::INTERNAL_SERVER_ERROR,
 47 |             StatusCode::BAD_GATEWAY,
 48 |             StatusCode::SERVICE_UNAVAILABLE,
 49 |             StatusCode::GATEWAY_TIMEOUT,
 50 |         ];
 51 | 
 52 |         if let Err(err) = &response {
 53 |             if let Some(status) = err.status() {
 54 |                 if retry_codes.contains(&status) {
 55 |                     Delay::new(retry_settings.delay).await;
 56 |                     continue;
 57 |                 }
 58 |             }
 59 | 
 60 |             return response;
 61 |         } else {
 62 |             return response;
 63 |         }
 64 |     }
 65 | 
 66 |     request.send().await
 67 | }
 68 | 
 69 | // Calls send_request_unprocessed but break is down
 70 | pub(crate) async fn send_request(
 71 |     request: RequestBuilder, retry_settings: RetrySettings,
 72 | ) -> reqwest::Result<(StatusCode, String)> {
 73 |     let response = send_request_unprocessed(request, retry_settings).await?;
 74 |     let status = response.status();
 75 |     let text = response.text().await?;
 76 | 
 77 |     Ok((status, text))
 78 | }
 79 | 
 80 | fn clone_request(request: &RequestBuilder) -> RequestBuilder {
 81 |     // Safety:
 82 |     //     Requests in this crate never use streams.
 83 |     //     .try_clone() will always succeed.
 84 |     request.try_clone().unwrap()
 85 | }
 86 | 
 87 | async fn fetch_page<T: DeserializeOwned>(
 88 |     client: Client, url: String, retry: RetrySettings,
 89 | ) -> Result<Vec<T>, BlockfrostError> {
 90 |     let request = client.get(&url);
 91 |     let (status, text) = send_request(request, retry)
 92 |         .await
 93 |         .map_err(|e| reqwest_error(&url, e))?;
 94 | 
 95 |     if !status.is_success() {
 96 |         return Err(process_error_response(&text, status, &url));
 97 |     }
 98 | 
 99 |     from_str::<Vec<T>>(&text).map_err(|e| json_error(url, text, e))
100 | }
101 | 
102 | pub(crate) async fn fetch_all_pages<T: DeserializeOwned>(
103 |     client: &Client, base_url: &str, retry: RetrySettings, pagination: Pagination,
104 |     batch_size: usize,
105 | ) -> Result<Vec<T>, BlockfrostError> {
106 |     let mut all = Vec::new();
107 |     let mut page_start = pagination.page;
108 |     let mut last_size = 0;
109 | 
110 |     loop {
111 |         let urls = Url::generate_batch(base_url, batch_size, page_start, pagination)?;
112 |         let client_cloned = client.clone();
113 | 
114 |         let pages: Vec<Vec<T>> = try_join_all(
115 |             urls.into_iter()
116 |                 .map(|u| fetch_page::<T>(client_cloned.clone(), u, retry)),
117 |         )
118 |         .await?;
119 | 
120 |         let mut saw_any = false;
121 | 
122 |         for mut page in pages {
123 |             if !page.is_empty() {
124 |                 saw_any = true;
125 |             }
126 | 
127 |             all.append(&mut page);
128 |         }
129 | 
130 |         if !saw_any || all.len() == last_size {
131 |             break;
132 |         }
133 | 
134 |         last_size = all.len();
135 | 
136 |         page_start += batch_size;
137 |     }
138 | 
139 |     Ok(all)
140 | }
141 | 
142 | #[cfg(test)]
143 | mod tests {
144 |     use super::*;
145 |     use crate::pagination::Pagination;
146 |     use httpmock::{Method::GET, Mock, MockServer};
147 |     use reqwest::Client;
148 | 
149 |     fn setup_test() -> (MockServer, Client, RetrySettings, String) {
150 |         let server = MockServer::start();
151 |         let client = Client::new();
152 |         let retry_settings = RetrySettings {
153 |             amount: 2,
154 |             delay: std::time::Duration::from_millis(100),
155 |         };
156 |         let base_url = server.url("/items");
157 | 
158 |         (server, client, retry_settings, base_url)
159 |     }
160 | 
161 |     fn setup_page_mock<'a>(server: &'a MockServer, page: u32, status: u16, body: &str) -> Mock<'a> {
162 |         server.mock(|when, then| {
163 |             when.method(GET)
164 |                 .path("/items")
165 |                 .query_param("page", page.to_string());
166 |             then.status(status)
167 |                 .header("Content-Type", "application/json")
168 |                 .body(body);
169 |         })
170 |     }
171 | 
172 |     #[tokio::test]
173 |     async fn test_fetch_all_pages_success_multi_page() {
174 |         let (server, client, retry_settings, base_url) = setup_test();
175 | 
176 |         // mocks
177 |         setup_page_mock(&server, 1, 200, "[1, 2]");
178 |         setup_page_mock(&server, 2, 200, "[3, 4]");
179 |         setup_page_mock(&server, 3, 200, "[]");
180 | 
181 |         let pagination = Pagination::all();
182 |         let batch_size = 1;
183 | 
184 |         let result =
185 |             fetch_all_pages::<u32>(&client, &base_url, retry_settings, pagination, batch_size)
186 |                 .await
187 |                 .unwrap();
188 | 
189 |         assert_eq!(vec![1, 2, 3, 4], result);
190 |     }
191 | 
192 |     #[tokio::test]
193 |     async fn test_fetch_all_pages_success_multi_page_different_batch_size() {
194 |         let (server, client, retry_settings, base_url) = setup_test();
195 | 
196 |         // mocks
197 |         setup_page_mock(&server, 1, 200, "[1, 2]");
198 |         setup_page_mock(&server, 2, 200, "[3, 4]");
199 |         setup_page_mock(&server, 3, 200, "[5, 6]");
200 |         setup_page_mock(&server, 4, 200, "[7, 8]");
201 |         setup_page_mock(&server, 5, 200, "[9]");
202 |         setup_page_mock(&server, 6, 200, "[]");
203 |         setup_page_mock(&server, 7, 200, "[]");
204 |         setup_page_mock(&server, 8, 200, "[]");
205 |         setup_page_mock(&server, 9, 200, "[]");
206 |         setup_page_mock(&server, 10, 200, "[]");
207 | 
208 |         let pagination = Pagination::all();
209 |         let batch_size = 5;
210 | 
211 |         let result =
212 |             fetch_all_pages::<u32>(&client, &base_url, retry_settings, pagination, batch_size)
213 |                 .await
214 |                 .unwrap();
215 | 
216 |         assert_eq!(vec![1, 2, 3, 4, 5, 6, 7, 8, 9], result);
217 |     }
218 | }
219 | 


--------------------------------------------------------------------------------
/src/api/endpoints/addresses.rs:
--------------------------------------------------------------------------------
  1 | use blockfrost_openapi::models::{
  2 |     address_content::AddressContent, address_content_extended::AddressContentExtended,
  3 |     address_content_total::AddressContentTotal,
  4 |     address_transactions_content_inner::AddressTransactionsContentInner,
  5 |     address_utxo_content_inner::AddressUtxoContentInner,
  6 | };
  7 | 
  8 | use crate::*;
  9 | 
 10 | impl BlockfrostAPI {
 11 |     pub async fn addresses(&self, address: &str) -> BlockfrostResult<AddressContent> {
 12 |         self.call_endpoint(format!("/addresses/{address}").as_str())
 13 |             .await
 14 |     }
 15 | 
 16 |     pub async fn addresses_extended(
 17 |         &self, address: &str,
 18 |     ) -> BlockfrostResult<AddressContentExtended> {
 19 |         self.call_endpoint(format!("/addresses/{address}/extended").as_str())
 20 |             .await
 21 |     }
 22 | 
 23 |     pub async fn addresses_total(&self, address: &str) -> BlockfrostResult<AddressContentTotal> {
 24 |         self.call_endpoint(format!("/addresses/{address}/total").as_str())
 25 |             .await
 26 |     }
 27 | 
 28 |     pub async fn addresses_utxos(
 29 |         &self, address: &str, pagination: Pagination,
 30 |     ) -> BlockfrostResult<Vec<AddressUtxoContentInner>> {
 31 |         self.call_paged_endpoint(format!("/addresses/{address}/utxos").as_str(), pagination)
 32 |             .await
 33 |     }
 34 | 
 35 |     pub async fn addresses_utxos_asset(
 36 |         &self, address: &str, asset: &str, pagination: Pagination,
 37 |     ) -> BlockfrostResult<Vec<AddressUtxoContentInner>> {
 38 |         self.call_paged_endpoint(
 39 |             format!("/addresses/{address}/utxos/{asset}").as_str(),
 40 |             pagination,
 41 |         )
 42 |         .await
 43 |     }
 44 | 
 45 |     pub async fn addresses_transactions(
 46 |         &self, address: &str, pagination: Pagination,
 47 |     ) -> BlockfrostResult<Vec<AddressTransactionsContentInner>> {
 48 |         self.call_paged_endpoint(
 49 |             format!("/addresses/{address}/transactions").as_str(),
 50 |             pagination,
 51 |         )
 52 |         .await
 53 |     }
 54 | }
 55 | 
 56 | #[cfg(test)]
 57 | mod tests {
 58 |     use super::*;
 59 |     use blockfrost_openapi::models::tx_content_output_amount_inner::TxContentOutputAmountInner;
 60 |     use serde_json::json;
 61 | 
 62 |     #[tokio::test]
 63 |     async fn test_address() {
 64 |         let json_value = json!({
 65 |             "address": "addr1qxqs59lphg8g6qndelq8xwqn60ag3aeyfcp33c2kdp46a09re5df3pzwwmyq946axfcejy5n4x0y99wqpgtp2gd0k09qsgy6pz",
 66 |             "amount": [
 67 |                 {
 68 |                     "unit": "lovelace",
 69 |                     "quantity": "42000000"
 70 |                 },
 71 |                 {
 72 |                     "unit": "b0d07d45fe9514f80213f4020e5a61241458be626841cde717cb38a76e7574636f696e",
 73 |                     "quantity": "12"
 74 |                 }
 75 |             ],
 76 |             "stake_address": "stake1ux3g2c9dx2nhhehyrezyxpkstartcqmu9hk63qgfkccw5rqttygt7",
 77 |             "type": "shelley",
 78 |             "script": false
 79 |         });
 80 |         serde_json::from_value::<AddressContent>(json_value).unwrap();
 81 |     }
 82 | 
 83 |     #[tokio::test]
 84 |     async fn test_address_total() {
 85 |         let json_value = json!({
 86 |             "address": "addr1qxqs59lphg8g6qndelq8xwqn60ag3aeyfcp33c2kdp46a09re5df3pzwwmyq946axfcejy5n4x0y99wqpgtp2gd0k09qsgy6pz",
 87 |             "received_sum": [
 88 |                 {
 89 |                     "unit": "lovelace",
 90 |                     "quantity": "42000000"
 91 |                 },
 92 |                 {
 93 |                     "unit": "b0d07d45fe9514f80213f4020e5a61241458be626841cde717cb38a76e7574636f696e",
 94 |                     "quantity": "12"
 95 |                 }
 96 |             ],
 97 |             "sent_sum": [
 98 |                 {
 99 |                     "unit": "lovelace",
100 |                     "quantity": "42000000"
101 |                 },
102 |                 {
103 |                     "unit": "b0d07d45fe9514f80213f4020e5a61241458be626841cde717cb38a76e7574636f696e",
104 |                     "quantity": "12"
105 |                 }
106 |             ],
107 |             "tx_count": 12
108 |         });
109 | 
110 |         serde_json::from_value::<AddressContentTotal>(json_value).unwrap();
111 |     }
112 | 
113 |     #[tokio::test]
114 |     async fn test_address_utxo() {
115 |         let json_value = json!(  [
116 |           {
117 |             "address": "hm",
118 |             "tx_index": 2,
119 |             "data_hash": null,
120 |             "tx_hash": "39a7a284c2a0948189dc45dec670211cd4d72f7b66c5726c08d9b3df11e44d58",
121 |             "output_index": 0,
122 |             "inline_datum": "0x68656c6c6f",
123 |             "reference_script_hash": null,
124 |             "amount": [
125 |               {
126 |                 "unit": "lovelace",
127 |                 "quantity": "42000000"
128 |               }
129 |             ],
130 |             "block": "7eb8e27d18686c7db9a18f8bbcfe34e3fed6e047afaa2d969904d15e934847e6"
131 |           },
132 |           {
133 |             "address": "hm2",
134 |             "tx_index": 2,
135 |             "data_hash": null,
136 |             "tx_hash": "4c4e67bafa15e742c13c592b65c8f74c769cd7d9af04c848099672d1ba391b49",
137 |             "output_index": 0,
138 |             "reference_script_hash": null,
139 |             "inline_datum": "0x68656c6c6f",
140 |             "amount": [
141 |               {
142 |                 "unit": "lovelace",
143 |                 "quantity": "729235000"
144 |               }
145 |             ],
146 |             "block": "953f1b80eb7c11a7ffcd67cbd4fde66e824a451aca5a4065725e5174b81685b7"
147 |           },
148 |           {
149 |             "address": "hm3",
150 |             "tx_hash": "768c63e27a1c816a83dc7b07e78af673b2400de8849ea7e7b734ae1333d100d2",
151 |             "output_index": 1,
152 |             "reference_script_hash": null,
153 |             "data_hash": null,
154 |             "inline_datum": "0x68656c6c6f",
155 |             "tx_index": 2,
156 |             "amount": [
157 |               {
158 |                 "unit": "lovelace",
159 |                 "quantity": "42000000"
160 |               },
161 |               {
162 |                 "unit": "b0d07d45fe9514f80213f4020e5a61241458be626841cde717cb38a76e7574636f696e",
163 |                 "quantity": "12"
164 |               }
165 |             ],
166 |             "block": "5c571f83fe6c784d3fbc223792627ccf0eea96773100f9aedecf8b1eda4544d7"
167 |           }
168 |         ]);
169 | 
170 |         serde_json::from_value::<Vec<AddressUtxoContentInner>>(json_value).unwrap();
171 |     }
172 | 
173 |     #[tokio::test]
174 |     async fn test_address_transaction() {
175 |         let json_value = json!([
176 |           {
177 |             "tx_hash": "8788591983aa73981fc92d6cddbbe643959f5a784e84b8bee0db15823f575a5b",
178 |             "tx_index": 6,
179 |             "block_height": 69,
180 |             "block_time": 4547
181 |           },
182 |           {
183 |             "tx_hash": "52e748c4dec58b687b90b0b40d383b9fe1f24c1a833b7395cdf07dd67859f46f",
184 |             "tx_index": 9,
185 |             "block_height": 4547,
186 |              "block_time": 42
187 |           },
188 |           {
189 |             "tx_hash": "e8073fd5318ff43eca18a852527166aa8008bee9ee9e891f585612b7e4ba700b",
190 |             "tx_index": 0,
191 |             "block_height": 564654,
192 |              "block_time": 666
193 |           }
194 |         ]);
195 |         serde_json::from_value::<Vec<AddressTransactionsContentInner>>(json_value).unwrap();
196 |     }
197 | 
198 |     #[tokio::test]
199 |     async fn test_transaction_amount() {
200 |         let json_value = json!({
201 |             "unit": "lovelace",
202 |             "quantity": "42000000"
203 |         });
204 | 
205 |         serde_json::from_value::<TxContentOutputAmountInner>(json_value).unwrap();
206 |     }
207 | }
208 | 


--------------------------------------------------------------------------------
/nix/sources.nix:
--------------------------------------------------------------------------------
  1 | # This file has been generated by Niv.
  2 | 
  3 | let
  4 | 
  5 |   #
  6 |   # The fetchers. fetch_<type> fetches specs of type <type>.
  7 |   #
  8 | 
  9 |   fetch_file = pkgs: name: spec:
 10 |     let
 11 |       name' = sanitizeName name + "-src";
 12 |     in
 13 |       if spec.builtin or true then
 14 |         builtins_fetchurl { inherit (spec) url sha256; name = name'; }
 15 |       else
 16 |         pkgs.fetchurl { inherit (spec) url sha256; name = name'; };
 17 | 
 18 |   fetch_tarball = pkgs: name: spec:
 19 |     let
 20 |       name' = sanitizeName name + "-src";
 21 |     in
 22 |       if spec.builtin or true then
 23 |         builtins_fetchTarball { name = name'; inherit (spec) url sha256; }
 24 |       else
 25 |         pkgs.fetchzip { name = name'; inherit (spec) url sha256; };
 26 | 
 27 |   fetch_git = name: spec:
 28 |     let
 29 |       ref =
 30 |         if spec ? ref then spec.ref else
 31 |           if spec ? branch then "refs/heads/${spec.branch}" else
 32 |             if spec ? tag then "refs/tags/${spec.tag}" else
 33 |               abort "In git source '${name}': Please specify `ref`, `tag` or `branch`!";
 34 |       submodules = if spec ? submodules then spec.submodules else false;
 35 |       submoduleArg =
 36 |         let
 37 |           nixSupportsSubmodules = builtins.compareVersions builtins.nixVersion "2.4" >= 0;
 38 |           emptyArgWithWarning =
 39 |             if submodules == true
 40 |             then
 41 |               builtins.trace
 42 |                 (
 43 |                   "The niv input \"${name}\" uses submodules "
 44 |                   + "but your nix's (${builtins.nixVersion}) builtins.fetchGit "
 45 |                   + "does not support them"
 46 |                 )
 47 |                 {}
 48 |             else {};
 49 |         in
 50 |           if nixSupportsSubmodules
 51 |           then { inherit submodules; }
 52 |           else emptyArgWithWarning;
 53 |     in
 54 |       builtins.fetchGit
 55 |         ({ url = spec.repo; inherit (spec) rev; inherit ref; } // submoduleArg);
 56 | 
 57 |   fetch_local = spec: spec.path;
 58 | 
 59 |   fetch_builtin-tarball = name: throw
 60 |     ''[${name}] The niv type "builtin-tarball" is deprecated. You should instead use `builtin = true`.
 61 |         $ niv modify ${name} -a type=tarball -a builtin=true'';
 62 | 
 63 |   fetch_builtin-url = name: throw
 64 |     ''[${name}] The niv type "builtin-url" will soon be deprecated. You should instead use `builtin = true`.
 65 |         $ niv modify ${name} -a type=file -a builtin=true'';
 66 | 
 67 |   #
 68 |   # Various helpers
 69 |   #
 70 | 
 71 |   # https://github.com/NixOS/nixpkgs/pull/83241/files#diff-c6f540a4f3bfa4b0e8b6bafd4cd54e8bR695
 72 |   sanitizeName = name:
 73 |     (
 74 |       concatMapStrings (s: if builtins.isList s then "-" else s)
 75 |         (
 76 |           builtins.split "[^[:alnum:]+._?=-]+"
 77 |             ((x: builtins.elemAt (builtins.match "\\.*(.*)" x) 0) name)
 78 |         )
 79 |     );
 80 | 
 81 |   # The set of packages used when specs are fetched using non-builtins.
 82 |   mkPkgs = sources: system:
 83 |     let
 84 |       sourcesNixpkgs =
 85 |         import (builtins_fetchTarball { inherit (sources.nixpkgs) url sha256; }) { inherit system; };
 86 |       hasNixpkgsPath = builtins.any (x: x.prefix == "nixpkgs") builtins.nixPath;
 87 |       hasThisAsNixpkgsPath = <nixpkgs> == ./.;
 88 |     in
 89 |       if builtins.hasAttr "nixpkgs" sources
 90 |       then sourcesNixpkgs
 91 |       else if hasNixpkgsPath && ! hasThisAsNixpkgsPath then
 92 |         import <nixpkgs> {}
 93 |       else
 94 |         abort
 95 |           ''
 96 |             Please specify either <nixpkgs> (through -I or NIX_PATH=nixpkgs=...) or
 97 |             add a package called "nixpkgs" to your sources.json.
 98 |           '';
 99 | 
100 |   # The actual fetching function.
101 |   fetch = pkgs: name: spec:
102 | 
103 |     if ! builtins.hasAttr "type" spec then
104 |       abort "ERROR: niv spec ${name} does not have a 'type' attribute"
105 |     else if spec.type == "file" then fetch_file pkgs name spec
106 |     else if spec.type == "tarball" then fetch_tarball pkgs name spec
107 |     else if spec.type == "git" then fetch_git name spec
108 |     else if spec.type == "local" then fetch_local spec
109 |     else if spec.type == "builtin-tarball" then fetch_builtin-tarball name
110 |     else if spec.type == "builtin-url" then fetch_builtin-url name
111 |     else
112 |       abort "ERROR: niv spec ${name} has unknown type ${builtins.toJSON spec.type}";
113 | 
114 |   # If the environment variable NIV_OVERRIDE_${name} is set, then use
115 |   # the path directly as opposed to the fetched source.
116 |   replace = name: drv:
117 |     let
118 |       saneName = stringAsChars (c: if isNull (builtins.match "[a-zA-Z0-9]" c) then "_" else c) name;
119 |       ersatz = builtins.getEnv "NIV_OVERRIDE_${saneName}";
120 |     in
121 |       if ersatz == "" then drv else
122 |         # this turns the string into an actual Nix path (for both absolute and
123 |         # relative paths)
124 |         if builtins.substring 0 1 ersatz == "/" then /. + ersatz else /. + builtins.getEnv "PWD" + "/${ersatz}";
125 | 
126 |   # Ports of functions for older nix versions
127 | 
128 |   # a Nix version of mapAttrs if the built-in doesn't exist
129 |   mapAttrs = builtins.mapAttrs or (
130 |     f: set: with builtins;
131 |     listToAttrs (map (attr: { name = attr; value = f attr set.${attr}; }) (attrNames set))
132 |   );
133 | 
134 |   # https://github.com/NixOS/nixpkgs/blob/0258808f5744ca980b9a1f24fe0b1e6f0fecee9c/lib/lists.nix#L295
135 |   range = first: last: if first > last then [] else builtins.genList (n: first + n) (last - first + 1);
136 | 
137 |   # https://github.com/NixOS/nixpkgs/blob/0258808f5744ca980b9a1f24fe0b1e6f0fecee9c/lib/strings.nix#L257
138 |   stringToCharacters = s: map (p: builtins.substring p 1 s) (range 0 (builtins.stringLength s - 1));
139 | 
140 |   # https://github.com/NixOS/nixpkgs/blob/0258808f5744ca980b9a1f24fe0b1e6f0fecee9c/lib/strings.nix#L269
141 |   stringAsChars = f: s: concatStrings (map f (stringToCharacters s));
142 |   concatMapStrings = f: list: concatStrings (map f list);
143 |   concatStrings = builtins.concatStringsSep "";
144 | 
145 |   # https://github.com/NixOS/nixpkgs/blob/8a9f58a375c401b96da862d969f66429def1d118/lib/attrsets.nix#L331
146 |   optionalAttrs = cond: as: if cond then as else {};
147 | 
148 |   # fetchTarball version that is compatible between all the versions of Nix
149 |   builtins_fetchTarball = { url, name ? null, sha256 }@attrs:
150 |     let
151 |       inherit (builtins) lessThan nixVersion fetchTarball;
152 |     in
153 |       if lessThan nixVersion "1.12" then
154 |         fetchTarball ({ inherit url; } // (optionalAttrs (!isNull name) { inherit name; }))
155 |       else
156 |         fetchTarball attrs;
157 | 
158 |   # fetchurl version that is compatible between all the versions of Nix
159 |   builtins_fetchurl = { url, name ? null, sha256 }@attrs:
160 |     let
161 |       inherit (builtins) lessThan nixVersion fetchurl;
162 |     in
163 |       if lessThan nixVersion "1.12" then
164 |         fetchurl ({ inherit url; } // (optionalAttrs (!isNull name) { inherit name; }))
165 |       else
166 |         fetchurl attrs;
167 | 
168 |   # Create the final "sources" from the config
169 |   mkSources = config:
170 |     mapAttrs (
171 |       name: spec:
172 |         if builtins.hasAttr "outPath" spec
173 |         then abort
174 |           "The values in sources.json should not have an 'outPath' attribute"
175 |         else
176 |           spec // { outPath = replace name (fetch config.pkgs name spec); }
177 |     ) config.sources;
178 | 
179 |   # The "config" used by the fetchers
180 |   mkConfig =
181 |     { sourcesFile ? if builtins.pathExists ./sources.json then ./sources.json else null
182 |     , sources ? if isNull sourcesFile then {} else builtins.fromJSON (builtins.readFile sourcesFile)
183 |     , system ? builtins.currentSystem
184 |     , pkgs ? mkPkgs sources system
185 |     }: rec {
186 |       # The sources, i.e. the attribute set of spec name to spec
187 |       inherit sources;
188 | 
189 |       # The "pkgs" (evaluated nixpkgs) to use for e.g. non-builtin fetchers
190 |       inherit pkgs;
191 |     };
192 | 
193 | in
194 | mkSources (mkConfig {}) // { __functor = _: settings: mkSources (mkConfig settings); }
195 | 


--------------------------------------------------------------------------------
/src/url.rs:
--------------------------------------------------------------------------------
  1 | use crate::{
  2 |     pagination::Pagination, CARDANO_MAINNET_URL, CARDANO_PREPROD_URL, CARDANO_PREVIEW_URL,
  3 | };
  4 | use std::error::Error;
  5 | use url::{form_urlencoded, Url as UrlI};
  6 | 
  7 | #[derive(Clone, Debug)]
  8 | pub struct Url;
  9 | 
 10 | impl Url {
 11 |     pub fn from_endpoint(base_url: &str, endpoint_url: &str) -> Result<String, Box<dyn Error>> {
 12 |         let url = Self::create_base_url(base_url, endpoint_url)?;
 13 | 
 14 |         Ok(url.to_string())
 15 |     }
 16 | 
 17 |     pub fn from_paginated_endpoint(
 18 |         base_url: &str, endpoint_url: &str, pagination: Pagination,
 19 |     ) -> Result<String, Box<dyn Error>> {
 20 |         let mut url = Self::create_base_url(base_url, endpoint_url)?;
 21 |         let mut query_pairs = form_urlencoded::Serializer::new(String::new());
 22 | 
 23 |         query_pairs.append_pair("page", pagination.page.to_string().as_str());
 24 |         query_pairs.append_pair("count", pagination.count.to_string().as_str());
 25 |         query_pairs.append_pair("order", pagination.order_to_string().as_str());
 26 | 
 27 |         let query = query_pairs.finish();
 28 | 
 29 |         url.set_query(Some(&query));
 30 | 
 31 |         Ok(url.to_string())
 32 |     }
 33 | 
 34 |     pub fn generate_batch(
 35 |         url: &str, batch_size: usize, start: usize, pagination: Pagination,
 36 |     ) -> Result<Vec<String>, Box<dyn Error>> {
 37 |         let mut result = Vec::new();
 38 |         let url = UrlI::parse(url)?;
 39 | 
 40 |         for page in start..(start + batch_size) {
 41 |             let mut query_pairs = form_urlencoded::Serializer::new(String::new());
 42 | 
 43 |             query_pairs.append_pair("page", page.to_string().as_str());
 44 |             query_pairs.append_pair("count", pagination.count.to_string().as_str());
 45 |             query_pairs.append_pair("order", pagination.order_to_string().as_str());
 46 | 
 47 |             let query = query_pairs.finish();
 48 | 
 49 |             let mut url = url.clone();
 50 | 
 51 |             url.set_query(Some(&query));
 52 | 
 53 |             result.push(url.to_string());
 54 |         }
 55 | 
 56 |         Ok(result)
 57 |     }
 58 | 
 59 |     pub fn get_base_url_from_project_id(project_id: &str) -> String {
 60 |         match project_id {
 61 |             id if id.starts_with("mainnet") => CARDANO_MAINNET_URL,
 62 |             id if id.starts_with("preview") => CARDANO_PREVIEW_URL,
 63 |             id if id.starts_with("preprod") => CARDANO_PREPROD_URL,
 64 |             _ => CARDANO_MAINNET_URL,
 65 |         }
 66 |         .to_string()
 67 |     }
 68 | 
 69 |     fn create_base_url(base_url: &str, endpoint_url: &str) -> Result<reqwest::Url, Box<dyn Error>> {
 70 |         let mut url = UrlI::parse(base_url)?;
 71 |         let endpoint = endpoint_url.strip_prefix('/').unwrap_or(endpoint_url);
 72 | 
 73 |         if !url.path().ends_with('/') {
 74 |             url.set_path(&format!("{}/", url.path()));
 75 |         }
 76 | 
 77 |         Ok(url.join(endpoint)?)
 78 |     }
 79 | }
 80 | 
 81 | #[cfg(test)]
 82 | mod tests {
 83 |     use super::*;
 84 |     use crate::pagination::{Order, Pagination};
 85 |     use crate::{CARDANO_MAINNET_URL, CARDANO_PREPROD_URL, CARDANO_PREVIEW_URL};
 86 |     use rstest::rstest;
 87 | 
 88 |     #[rstest]
 89 |     #[case("http://example.com", "api/data", "http://example.com/api/data")]
 90 |     #[case("http://example.com/", "/api/data", "http://example.com/api/data")]
 91 |     #[case(
 92 |         "http://example.com/basepath",
 93 |         "endpoint",
 94 |         "http://example.com/basepath/endpoint"
 95 |     )]
 96 |     fn test_from_endpoint_success(
 97 |         #[case] base_url: &str, #[case] endpoint_url: &str, #[case] expected: &str,
 98 |     ) {
 99 |         let result = Url::from_endpoint(base_url, endpoint_url).unwrap();
100 |         assert_eq!(result, expected);
101 |     }
102 | 
103 |     #[rstest]
104 |     #[case("not a url", "api", true)]
105 |     #[case("http://example.com", "api", false)]
106 |     fn test_from_endpoint_error(
107 |         #[case] base_url: &str, #[case] endpoint_url: &str, #[case] should_err: bool,
108 |     ) {
109 |         let result = Url::from_endpoint(base_url, endpoint_url);
110 | 
111 |         assert_eq!(result.is_err(), should_err);
112 |     }
113 | 
114 |     #[rstest]
115 |     #[case(
116 |         "http://example.com",
117 |         "api/items",
118 |         2,
119 |         5,
120 |         Order::Desc,
121 |         "http://example.com/api/items?page=2&count=5&order=desc"
122 |     )]
123 |     #[case(
124 |         "https://foo.bar",
125 |         "data",
126 |         1,
127 |         10,
128 |         Order::Asc,
129 |         "https://foo.bar/data?page=1&count=10&order=asc"
130 |     )]
131 |     fn test_from_paginated_endpoint(
132 |         #[case] base_url: &str, #[case] endpoint_url: &str, #[case] page: usize,
133 |         #[case] count: usize, #[case] order: Order, #[case] expected: &str,
134 |     ) {
135 |         let pagination = Pagination {
136 |             page,
137 |             count,
138 |             order,
139 |             fetch_all: false,
140 |         };
141 |         let result = Url::from_paginated_endpoint(base_url, endpoint_url, pagination).unwrap();
142 |         assert_eq!(result, expected);
143 |     }
144 | 
145 |     #[rstest]
146 |     #[case("http://example.com/api/data", 3, 1, 10, Order::Asc,
147 |            vec![
148 |                "http://example.com/api/data?page=1&count=10&order=asc",
149 |                "http://example.com/api/data?page=2&count=10&order=asc",
150 |                "http://example.com/api/data?page=3&count=10&order=asc",
151 |            ])]
152 |     fn test_generate_batch(
153 |         #[case] base: &str, #[case] batch_size: usize, #[case] page_start: usize,
154 |         #[case] count: usize, #[case] order: Order, #[case] expected: Vec<&str>,
155 |     ) {
156 |         let pagination = Pagination {
157 |             page: 0,
158 |             count,
159 |             order,
160 |             fetch_all: false,
161 |         };
162 |         let urls = Url::generate_batch(base, batch_size, page_start, pagination).unwrap();
163 |         let expected: Vec<String> = expected.into_iter().map(String::from).collect();
164 |         assert_eq!(urls, expected);
165 |     }
166 | 
167 |     #[rstest]
168 |     #[case(
169 |             "http://example.com/api/data",
170 |             0,
171 |             1,
172 |             100,
173 |             Order::Asc,
174 |             vec![]
175 |         )]
176 |     #[case(
177 |             "http://example.com/api/data",
178 |             2,
179 |             10,
180 |             50,
181 |             Order::Desc,
182 |             vec![
183 |                 "http://example.com/api/data?page=10&count=50&order=desc",
184 |                 "http://example.com/api/data?page=11&count=50&order=desc"
185 |             ]
186 |         )]
187 |     #[case(
188 |             "https://test.net/resources",
189 |             3,
190 |             5,
191 |             25,
192 |             Order::Asc,
193 |             vec![
194 |                 "https://test.net/resources?page=5&count=25&order=asc",
195 |                 "https://test.net/resources?page=6&count=25&order=asc",
196 |                 "https://test.net/resources?page=7&count=25&order=asc"
197 |             ]
198 |         )]
199 |     fn test_generate_batch_extended(
200 |         #[case] base: &str, #[case] batch_size: usize, #[case] page_start: usize,
201 |         #[case] count: usize, #[case] order: Order, #[case] expected: Vec<&str>,
202 |     ) {
203 |         let pagination = Pagination {
204 |             page: 0,
205 |             count,
206 |             order,
207 |             fetch_all: false,
208 |         };
209 |         let urls = Url::generate_batch(base, batch_size, page_start, pagination).unwrap();
210 |         let expected: Vec<String> = expected.into_iter().map(String::from).collect();
211 | 
212 |         assert_eq!(
213 |             urls, expected,
214 |             "Failed for base: {base}, batch_size: {batch_size}, page_start: {page_start}",
215 |         );
216 |     }
217 | 
218 |     #[test]
219 |     fn test_get_base_url_from_project_id() {
220 |         let cases = vec![
221 |             ("mainnet123", CARDANO_MAINNET_URL),
222 |             ("previewABC", CARDANO_PREVIEW_URL),
223 |             ("preprodXYZ", CARDANO_PREPROD_URL),
224 |             ("unknown", CARDANO_MAINNET_URL),
225 |         ];
226 | 
227 |         for (project_id, expected) in cases {
228 |             let url = Url::get_base_url_from_project_id(project_id);
229 |             assert_eq!(url, expected.to_string(), "for project_id {project_id}");
230 |         }
231 |     }
232 | }
233 | 


--------------------------------------------------------------------------------
/src/api/endpoints/pools.rs:
--------------------------------------------------------------------------------
  1 | use crate::*;
  2 | use blockfrost_openapi::models::{
  3 |     pool::Pool, pool_delegators_inner::PoolDelegatorsInner, pool_history_inner::PoolHistoryInner,
  4 |     pool_list_retire_inner::PoolListRetireInner, pool_metadata::PoolMetadata,
  5 |     pool_updates_inner::PoolUpdatesInner,
  6 |     tx_content_pool_certs_inner_relays_inner::TxContentPoolCertsInnerRelaysInner,
  7 | };
  8 | 
  9 | impl BlockfrostAPI {
 10 |     pub async fn pools_by_id(&self, pool_id: &str) -> BlockfrostResult<Pool> {
 11 |         self.call_endpoint(format!("/pools/{pool_id}").as_str())
 12 |             .await
 13 |     }
 14 | 
 15 |     pub async fn pools_metadata(&self, pool_id: &str) -> BlockfrostResult<PoolMetadata> {
 16 |         self.call_endpoint(format!("/pools/{pool_id}/metadata").as_str())
 17 |             .await
 18 |     }
 19 | 
 20 |     pub async fn pools(&self, pagination: Pagination) -> BlockfrostResult<Vec<String>> {
 21 |         self.call_paged_endpoint("/pools", pagination).await
 22 |     }
 23 | 
 24 |     pub async fn pools_retired(
 25 |         &self, pagination: Pagination,
 26 |     ) -> BlockfrostResult<Vec<PoolListRetireInner>> {
 27 |         self.call_paged_endpoint("/pools/retired", pagination).await
 28 |     }
 29 | 
 30 |     pub async fn pools_retiring(
 31 |         &self, pagination: Pagination,
 32 |     ) -> BlockfrostResult<Vec<PoolListRetireInner>> {
 33 |         self.call_paged_endpoint("/pools/retiring", pagination)
 34 |             .await
 35 |     }
 36 | 
 37 |     pub async fn pools_history(
 38 |         &self, pool_id: &str, pagination: Pagination,
 39 |     ) -> BlockfrostResult<Vec<PoolHistoryInner>> {
 40 |         self.call_paged_endpoint(format!("/pools/{pool_id}/history").as_str(), pagination)
 41 |             .await
 42 |     }
 43 | 
 44 |     pub async fn pools_relays(
 45 |         &self, pool_id: &str,
 46 |     ) -> BlockfrostResult<Vec<TxContentPoolCertsInnerRelaysInner>> {
 47 |         self.call_endpoint(format!("/pools/{pool_id}/relays").as_str())
 48 |             .await
 49 |     }
 50 | 
 51 |     pub async fn pools_delegators(
 52 |         &self, pool_id: &str, pagination: Pagination,
 53 |     ) -> BlockfrostResult<Vec<PoolDelegatorsInner>> {
 54 |         self.call_paged_endpoint(format!("/pools/{pool_id}/delegators").as_str(), pagination)
 55 |             .await
 56 |     }
 57 | 
 58 |     pub async fn pools_blocks(
 59 |         &self, pool_id: &str, pagination: Pagination,
 60 |     ) -> BlockfrostResult<Vec<String>> {
 61 |         self.call_paged_endpoint(format!("/pools/{pool_id}/blocks").as_str(), pagination)
 62 |             .await
 63 |     }
 64 | 
 65 |     pub async fn pools_updates(
 66 |         &self, pool_id: &str, pagination: Pagination,
 67 |     ) -> BlockfrostResult<Vec<PoolUpdatesInner>> {
 68 |         self.call_paged_endpoint(format!("/pools/{pool_id}/updates").as_str(), pagination)
 69 |             .await
 70 |     }
 71 | }
 72 | #[cfg(test)]
 73 | mod tests {
 74 |     use super::*;
 75 |     use serde_json::json;
 76 | 
 77 |     #[tokio::test]
 78 |     async fn test_pools() {
 79 |         let json_value = json!([
 80 |             "pool1pu5jlj4q9w9jlxeu370a3c9myx47md5j5m2str0naunn2q3lkdy",
 81 |             "pool1hn7hlwrschqykupwwrtdfkvt2u4uaxvsgxyh6z63703p2knj288",
 82 |             "pool1ztjyjfsh432eqetadf82uwuxklh28xc85zcphpwq6mmezavzad2"
 83 |         ]);
 84 | 
 85 |         serde_json::from_value::<Vec<String>>(json_value).unwrap();
 86 |     }
 87 | 
 88 |     #[tokio::test]
 89 |     async fn test_pools_retired() {
 90 |         let json_value = json!([
 91 |             {
 92 |                 "pool_id": "pool19u64770wqp6s95gkajc8udheske5e6ljmpq33awxk326zjaza0q",
 93 |                 "epoch": 225
 94 |             },
 95 |             {
 96 |                 "pool_id": "pool1dvla4zq98hpvacv20snndupjrqhuc79zl6gjap565nku6et5zdx",
 97 |                 "epoch": 215
 98 |             },
 99 |             {
100 |                 "pool_id": "pool1wvccajt4eugjtf3k0ja3exjqdj7t8egsujwhcw4tzj4rzsxzw5w",
101 |                 "epoch": 231
102 |             }
103 |         ]);
104 | 
105 |         serde_json::from_value::<Vec<PoolListRetireInner>>(json_value).unwrap();
106 |     }
107 | 
108 |     #[tokio::test]
109 |     async fn test_pools_retiring() {
110 |         let json_value = json!([
111 |             {
112 |                 "pool_id": "pool19u64770wqp6s95gkajc8udheske5e6ljmpq33awxk326zjaza0q",
113 |                 "epoch": 225
114 |             },
115 |             {
116 |                 "pool_id": "pool1dvla4zq98hpvacv20snndupjrqhuc79zl6gjap565nku6et5zdx",
117 |                 "epoch": 215
118 |             },
119 |             {
120 |                 "pool_id": "pool1wvccajt4eugjtf3k0ja3exjqdj7t8egsujwhcw4tzj4rzsxzw5w",
121 |                 "epoch": 231
122 |             }
123 |         ]);
124 |         serde_json::from_value::<Vec<PoolListRetireInner>>(json_value).unwrap();
125 |     }
126 | 
127 |     #[tokio::test]
128 |     async fn test_pools_by_id() {
129 |         let json_value = json!({
130 |           "pool_id": "pool1pu5jlj4q9w9jlxeu370a3c9myx47md5j5m2str0naunn2q3lkdy",
131 |           "hex": "0f292fcaa02b8b2f9b3c8f9fd8e0bb21abedb692a6d5058df3ef2735",
132 |           "vrf_key": "0b5245f9934ec2151116fb8ec00f35fd00e0aa3b075c4ed12cce440f999d8233",
133 |           "blocks_minted": 69,
134 |           "live_stake": "6900000000",
135 |           "live_size": 0.42,
136 |           "live_saturation": 0.93,
137 |           "live_delegators": 127,
138 |           "active_stake": "4200000000",
139 |           "blocks_epoch": 21,
140 |           "active_size": 0.43,
141 |           "declared_pledge": "5000000000",
142 |           "live_pledge": "5000000001",
143 |           "margin_cost": 0.05,
144 |           "fixed_cost": "340000000",
145 |           "reward_account": "stake1uxkptsa4lkr55jleztw43t37vgdn88l6ghclfwuxld2eykgpgvg3f",
146 |           "owners": [
147 |             "stake1u98nnlkvkk23vtvf9273uq7cph5ww6u2yq2389psuqet90sv4xv9v"
148 |           ],
149 |           "registration": [
150 |             "9f83e5484f543e05b52e99988272a31da373f3aab4c064c76db96643a355d9dc",
151 |             "7ce3b8c433bf401a190d58c8c483d8e3564dfd29ae8633c8b1b3e6c814403e95",
152 |             "3e6e1200ce92977c3fe5996bd4d7d7e192bcb7e231bc762f9f240c76766535b9"
153 |           ],
154 |           "retirement": [
155 |             "252f622976d39e646815db75a77289cf16df4ad2b287dd8e3a889ce14c13d1a8"
156 |           ]
157 |         });
158 |         serde_json::from_value::<Pool>(json_value).unwrap();
159 |     }
160 | 
161 |     #[tokio::test]
162 |     async fn test_pools_history() {
163 |         let json_value = json!([
164 |             {
165 |                 "epoch": 233,
166 |                 "blocks": 22,
167 |                 "active_stake": "20485965693569",
168 |                 "active_size": 1.2345,
169 |                 "delegators_count": 115,
170 |                 "rewards": "206936253674159",
171 |                 "fees": "1290968354"
172 |             }
173 |         ]);
174 |         serde_json::from_value::<Vec<PoolHistoryInner>>(json_value).unwrap();
175 |     }
176 | 
177 |     #[tokio::test]
178 |     async fn test_pools_metadata() {
179 |         let json_value = json!({
180 |           "pool_id": "pool1pu5jlj4q9w9jlxeu370a3c9myx47md5j5m2str0naunn2q3lkdy",
181 |           "hex": "0f292fcaa02b8b2f9b3c8f9fd8e0bb21abedb692a6d5058df3ef2735",
182 |           "url": "https://stakenuts.com/mainnet.json",
183 |           "hash": "47c0c68cb57f4a5b4a87bad896fc274678e7aea98e200fa14a1cb40c0cab1d8c",
184 |           "ticker": "NUTS",
185 |           "name": "Stake Nuts",
186 |           "description": "The best pool ever",
187 |           "homepage": "https://stakentus.com/"
188 |         });
189 | 
190 |         serde_json::from_value::<PoolMetadata>(json_value).unwrap();
191 |     }
192 | 
193 |     #[tokio::test]
194 |     async fn test_pools_relays() {
195 |         let json_value = json!([
196 |             {
197 |                 "ipv4": "4.4.4.4",
198 |                 "ipv6": "https://stakenuts.com/mainnet.json",
199 |                 "dns": "relay1.stakenuts.com",
200 |                 "dns_srv": "_relays._tcp.relays.stakenuts.com",
201 |                 "port": 3001
202 |             }
203 |         ]);
204 | 
205 |         serde_json::from_value::<Vec<TxContentPoolCertsInnerRelaysInner>>(json_value).unwrap();
206 |     }
207 | 
208 |     #[tokio::test]
209 |     async fn test_pool_delegators() {
210 |         let json_value = json!([
211 |             {
212 |                 "address": "stake1ux4vspfvwuus9uwyp5p3f0ky7a30jq5j80jxse0fr7pa56sgn8kha",
213 |                 "live_stake": "1137959159981411"
214 |             },
215 |             {
216 |                 "address": "stake1uylayej7esmarzd4mk4aru37zh9yz0luj3g9fsvgpfaxulq564r5u",
217 |                 "live_stake": "16958865648"
218 |             },
219 |             {
220 |                 "address": "stake1u8lr2pnrgf8f7vrs9lt79hc3sxm8s2w4rwvgpncks3axx6q93d4ck",
221 |                 "live_stake": "18605647"
222 |             }
223 |         ]);
224 | 
225 |         serde_json::from_value::<Vec<PoolDelegatorsInner>>(json_value).unwrap();
226 |     }
227 | 
228 |     #[tokio::test]
229 |     async fn test_pools_blocks() {
230 |         let json_value = json!([
231 |             "d8982ca42cfe76b747cc681d35d671050a9e41e9cfe26573eb214e94fe6ff21d",
232 |             "026436c539e2ce84c7f77ffe669f4e4bbbb3b9c53512e5857dcba8bb0b4e9a8c",
233 |             "bcc8487f419b8c668a18ea2120822a05df6dfe1de1f0fac3feba88cf760f303c",
234 |             "86bf7b4a274e0f8ec9816171667c1b4a0cfc661dc21563f271acea9482b62df7"
235 |         ]);
236 | 
237 |         serde_json::from_value::<Vec<String>>(json_value).unwrap();
238 |     }
239 | 
240 |     #[tokio::test]
241 |     async fn test_pools_updates() {
242 |         let json_value = json!([
243 |             {
244 |                 "tx_hash": "6804edf9712d2b619edb6ac86861fe93a730693183a262b165fcc1ba1bc99cad",
245 |                 "cert_index": 0,
246 |                 "action": "registered"
247 |             },
248 |             {
249 |                 "tx_hash": "9c190bc1ac88b2ab0c05a82d7de8b71b67a9316377e865748a89d4426c0d3005",
250 |                 "cert_index": 0,
251 |                 "action": "deregistered"
252 |             },
253 |             {
254 |                 "tx_hash": "e14a75b0eb2625de7055f1f580d70426311b78e0d36dd695a6bdc96c7b3d80e0",
255 |                 "cert_index": 1,
256 |                 "action": "registered"
257 |             }
258 |         ]);
259 | 
260 |         serde_json::from_value::<Vec<PoolUpdatesInner>>(json_value).unwrap();
261 |     }
262 | }
263 | 


--------------------------------------------------------------------------------
/src/api/endpoints/epochs.rs:
--------------------------------------------------------------------------------
  1 | use crate::*;
  2 | use blockfrost_openapi::models::{
  3 |     epoch_content::EpochContent, epoch_param_content::EpochParamContent,
  4 |     epoch_stake_content_inner::EpochStakeContentInner,
  5 |     epoch_stake_pool_content_inner::EpochStakePoolContentInner,
  6 | };
  7 | 
  8 | impl BlockfrostAPI {
  9 |     pub async fn epochs_latest(&self) -> BlockfrostResult<EpochContent> {
 10 |         self.call_endpoint("/epochs/latest".to_string().as_str())
 11 |             .await
 12 |     }
 13 | 
 14 |     pub async fn epochs_latest_parameters(&self) -> BlockfrostResult<EpochParamContent> {
 15 |         self.call_endpoint("/epochs/latest/parameters").await
 16 |     }
 17 | 
 18 |     pub async fn epochs_by_number(&self, number: i32) -> BlockfrostResult<EpochContent> {
 19 |         self.call_endpoint(format!("/epochs/{number}").as_str())
 20 |             .await
 21 |     }
 22 | 
 23 |     pub async fn epochs_parameters(&self, number: i32) -> BlockfrostResult<EpochParamContent> {
 24 |         self.call_endpoint(format!("/epochs/{number}/parameters").as_str())
 25 |             .await
 26 |     }
 27 | 
 28 |     pub async fn epochs_next(
 29 |         &self, number: i32, pagination: Pagination,
 30 |     ) -> BlockfrostResult<Vec<EpochContent>> {
 31 |         self.call_paged_endpoint(format!("/epochs/{number}/next").as_str(), pagination)
 32 |             .await
 33 |     }
 34 | 
 35 |     pub async fn epochs_previous(
 36 |         &self, number: i32, pagination: Pagination,
 37 |     ) -> BlockfrostResult<Vec<EpochContent>> {
 38 |         self.call_paged_endpoint(format!("/epochs/{number}/previous",).as_str(), pagination)
 39 |             .await
 40 |     }
 41 | 
 42 |     pub async fn epochs_stakes(
 43 |         &self, number: i32, pagination: Pagination,
 44 |     ) -> BlockfrostResult<Vec<EpochStakeContentInner>> {
 45 |         self.call_paged_endpoint(format!("/epochs/{number}/stakes").as_str(), pagination)
 46 |             .await
 47 |     }
 48 | 
 49 |     pub async fn epochs_stakes_by_pool(
 50 |         &self, number: i32, pool_id: &str, pagination: Pagination,
 51 |     ) -> BlockfrostResult<Vec<EpochStakePoolContentInner>> {
 52 |         self.call_paged_endpoint(
 53 |             format!("/epochs/{number}/stakes/{pool_id}").as_str(),
 54 |             pagination,
 55 |         )
 56 |         .await
 57 |     }
 58 | 
 59 |     pub async fn epochs_blocks(&self, number: i32) -> BlockfrostResult<Vec<String>> {
 60 |         self.call_endpoint(format!("/epochs/{number}/blocks").as_str())
 61 |             .await
 62 |     }
 63 | 
 64 |     pub async fn epochs_blocks_by_pool(
 65 |         &self, number: i32, pool_id: &str,
 66 |     ) -> BlockfrostResult<Vec<String>> {
 67 |         self.call_endpoint(format!("/epochs/{number}/blocks/{pool_id}").as_str())
 68 |             .await
 69 |     }
 70 | }
 71 | 
 72 | #[cfg(test)]
 73 | mod tests {
 74 |     use super::*;
 75 |     use blockfrost_openapi::models::{
 76 |         epoch_content::EpochContent, epoch_param_content::EpochParamContent,
 77 |     };
 78 |     use serde_json::json;
 79 | 
 80 |     #[tokio::test]
 81 |     async fn test_epochs_latest() {
 82 |         let json_value = json!({
 83 |             "epoch": 225,
 84 |             "start_time": 1603403091,
 85 |             "end_time": 1603835086,
 86 |             "first_block_time": 1603403092,
 87 |             "last_block_time": 1603835084,
 88 |             "block_count": 21298,
 89 |             "tx_count": 17856,
 90 |             "output": "7849943934049314",
 91 |             "fees": "4203312194",
 92 |             "active_stake": "784953934049314"
 93 |         });
 94 | 
 95 |         serde_json::from_value::<EpochContent>(json_value).unwrap();
 96 |     }
 97 | 
 98 |     #[tokio::test]
 99 |     async fn test_epochs_latest_parameters() {
100 |         // not building with `json!` macro because this payload is too big
101 |         let mut json_value = serde_json::Map::new();
102 |         json_value.insert("epoch".to_string(), json!(225));
103 |         json_value.insert("min_fee_a".to_string(), json!(44));
104 |         json_value.insert("min_fee_b".to_string(), json!(155381));
105 |         json_value.insert("max_block_size".to_string(), json!(65536));
106 |         json_value.insert("max_tx_size".to_string(), json!(16384));
107 |         json_value.insert("max_block_header_size".to_string(), json!(1100));
108 |         json_value.insert("key_deposit".to_string(), json!("2000000"));
109 |         json_value.insert("pool_deposit".to_string(), json!("500000000"));
110 |         json_value.insert("e_max".to_string(), json!(18));
111 |         json_value.insert("n_opt".to_string(), json!(150));
112 |         json_value.insert("a0".to_string(), json!(0.3));
113 |         json_value.insert("rho".to_string(), json!(0.003));
114 |         json_value.insert("tau".to_string(), json!(0.2));
115 |         json_value.insert("decentralisation_param".to_string(), json!(0.5));
116 |         json_value.insert("extra_entropy".to_string(), json!(null));
117 |         json_value.insert("protocol_major_ver".to_string(), json!(2));
118 |         json_value.insert("protocol_minor_ver".to_string(), json!(0));
119 |         json_value.insert("min_utxo".to_string(), json!("1000000"));
120 |         json_value.insert("min_pool_cost".to_string(), json!("340000000"));
121 |         json_value.insert(
122 |             "nonce".to_string(),
123 |             json!("1a3be38bcbb7911969283716ad7aa550250226b76a61fc51cc9a9a35d9276d81"),
124 |         );
125 |         json_value.insert("price_mem".to_string(), json!(0.001));
126 |         json_value.insert("price_step".to_string(), json!(0.01));
127 |         json_value.insert("max_tx_ex_mem".to_string(), json!("11000000000"));
128 |         json_value.insert("max_tx_ex_steps".to_string(), json!("11000000000"));
129 |         json_value.insert("max_block_ex_mem".to_string(), json!("110000000000"));
130 |         json_value.insert("max_block_ex_steps".to_string(), json!("110000000000"));
131 |         json_value.insert("max_val_size".to_string(), json!("5000"));
132 |         json_value.insert("collateral_percent".to_string(), json!(15));
133 |         json_value.insert("max_collateral_inputs".to_string(), json!(6));
134 |         json_value.insert("coins_per_utxo_word".to_string(), json!("34482"));
135 |         json_value.insert("cost_models".to_string(), json!(null));
136 |         json_value.insert("coins_per_utxo_size".to_string(), json!("34482"));
137 |         json_value.insert("pvt_motion_no_confidence".to_string(), json!(null));
138 |         json_value.insert("pvt_committee_normal".to_string(), json!(null));
139 |         json_value.insert("pvt_committee_no_confidence".to_string(), json!(null));
140 |         json_value.insert("pvt_hard_fork_initiation".to_string(), json!(null));
141 |         json_value.insert("dvt_motion_no_confidence".to_string(), json!(null));
142 |         json_value.insert("dvt_committee_normal".to_string(), json!(null));
143 |         json_value.insert("dvt_committee_no_confidence".to_string(), json!(null));
144 |         json_value.insert("dvt_update_to_constitution".to_string(), json!(null));
145 |         json_value.insert("dvt_hard_fork_initiation".to_string(), json!(null));
146 |         json_value.insert("dvt_p_p_network_group".to_string(), json!(null));
147 |         json_value.insert("dvt_p_p_economic_group".to_string(), json!(null));
148 |         json_value.insert("dvt_p_p_technical_group".to_string(), json!(null));
149 |         json_value.insert("dvt_p_p_gov_group".to_string(), json!(null));
150 |         json_value.insert("dvt_treasury_withdrawal".to_string(), json!(null));
151 |         json_value.insert("committee_min_size".to_string(), json!(null));
152 |         json_value.insert("committee_max_term_length".to_string(), json!(null));
153 |         json_value.insert("gov_action_lifetime".to_string(), json!(null));
154 |         json_value.insert("gov_action_deposit".to_string(), json!(null));
155 |         json_value.insert("drep_deposit".to_string(), json!(null));
156 |         json_value.insert("drep_activity".to_string(), json!(null));
157 |         json_value.insert("pvtpp_security_group".to_string(), json!(null));
158 |         json_value.insert("pvt_p_p_security_group".to_string(), json!(null));
159 |         json_value.insert("min_fee_ref_script_cost_per_byte".to_string(), json!(null));
160 |         let json_value = serde_json::Value::Object(json_value);
161 | 
162 |         serde_json::from_value::<EpochParamContent>(json_value).unwrap();
163 |     }
164 | 
165 |     #[tokio::test]
166 |     async fn test_epochs_next() {
167 |         let json_value = json!([
168 |             {
169 |                 "epoch": 225,
170 |                 "start_time": 1603403091,
171 |                 "end_time": 1603835086,
172 |                 "first_block_time": 1603403092,
173 |                 "last_block_time": 1603835084,
174 |                 "block_count": 21298,
175 |                 "tx_count": 17856,
176 |                 "output": "7849943934049314",
177 |                 "fees": "4203312194",
178 |                 "active_stake": "784953934049314"
179 |             }
180 |         ]);
181 | 
182 |         serde_json::from_value::<Vec<EpochContent>>(json_value).unwrap();
183 |     }
184 | 
185 |     #[tokio::test]
186 |     async fn test_epochs_stakes() {
187 |         let json_value = json!([
188 |             {
189 |                 "stake_address": "stake1u9l5q5jwgelgagzyt6nuaasefgmn8pd25c8e9qpeprq0tdcp0e3uk",
190 |                 "pool_id": "pool1pu5jlj4q9w9jlxeu370a3c9myx47md5j5m2str0naunn2q3lkdy",
191 |                 "amount": "4440295078"
192 |             }
193 |         ]);
194 | 
195 |         serde_json::from_value::<Vec<EpochStakeContentInner>>(json_value).unwrap();
196 |     }
197 | 
198 |     #[tokio::test]
199 |     async fn test_epochs_stakes_by_pool() {
200 |         let json_value = json!([
201 |             {
202 |                 "stake_address": "stake1u9l5q5jwgelgagzyt6nuaasefgmn8pd25c8e9qpeprq0tdcp0e3uk",
203 |                 "amount": "4440295078"
204 |             }
205 |         ]);
206 | 
207 |         serde_json::from_value::<Vec<EpochStakePoolContentInner>>(json_value).unwrap();
208 |     }
209 | 
210 |     #[tokio::test]
211 |     async fn test_epochs_blocks() {
212 |         let json_value = json!([
213 |             "d0fa315687e99ccdc96b14cc2ea74a767405d64427b648c470731a9b69e4606e",
214 |             "38bc6efb92a830a0ed22a64f979d120d26483fd3c811f6622a8c62175f530878",
215 |             "f3258fcd8b975c061b4fcdcfcbb438807134d6961ec278c200151274893b6b7d"
216 |         ]);
217 | 
218 |         serde_json::from_value::<Vec<String>>(json_value).unwrap();
219 |     }
220 | }
221 | 


--------------------------------------------------------------------------------
/src/api/endpoints/accounts.rs:
--------------------------------------------------------------------------------
  1 | use crate::*;
  2 | use blockfrost_openapi::models::{
  3 |     account_addresses_assets_inner::AccountAddressesAssetsInner,
  4 |     account_addresses_content_inner::AccountAddressesContentInner,
  5 |     account_addresses_total::AccountAddressesTotal, account_content::AccountContent,
  6 |     account_delegation_content_inner::AccountDelegationContentInner,
  7 |     account_history_content_inner::AccountHistoryContentInner,
  8 |     account_mir_content_inner::AccountMirContentInner,
  9 |     account_registration_content_inner::AccountRegistrationContentInner,
 10 |     account_reward_content_inner::AccountRewardContentInner,
 11 |     account_withdrawal_content_inner::AccountWithdrawalContentInner,
 12 | };
 13 | 
 14 | impl BlockfrostAPI {
 15 |     pub async fn accounts(&self, stake_address: &str) -> BlockfrostResult<AccountContent> {
 16 |         self.call_endpoint(format!("/accounts/{stake_address}").as_str())
 17 |             .await
 18 |     }
 19 | 
 20 |     /// Reward history of a specific account.
 21 |     pub async fn accounts_rewards(
 22 |         &self, stake_address: &str, pagination: Pagination,
 23 |     ) -> BlockfrostResult<Vec<AccountRewardContentInner>> {
 24 |         self.call_paged_endpoint(
 25 |             format!("/accounts/{stake_address}/rewards").as_str(),
 26 |             pagination,
 27 |         )
 28 |         .await
 29 |     }
 30 | 
 31 |     /// History of a specific account.
 32 |     pub async fn accounts_history(
 33 |         &self, stake_address: &str, pagination: Pagination,
 34 |     ) -> BlockfrostResult<Vec<AccountHistoryContentInner>> {
 35 |         self.call_paged_endpoint(
 36 |             format!("/accounts/{stake_address}/history").as_str(),
 37 |             pagination,
 38 |         )
 39 |         .await
 40 |     }
 41 | 
 42 |     pub async fn accounts_delegations(
 43 |         &self, stake_address: &str, pagination: Pagination,
 44 |     ) -> BlockfrostResult<Vec<AccountDelegationContentInner>> {
 45 |         self.call_paged_endpoint(
 46 |             format!("/accounts/{stake_address}/delegations").as_str(),
 47 |             pagination,
 48 |         )
 49 |         .await
 50 |     }
 51 | 
 52 |     pub async fn accounts_registrations(
 53 |         &self, stake_address: &str, pagination: Pagination,
 54 |     ) -> BlockfrostResult<Vec<AccountRegistrationContentInner>> {
 55 |         self.call_paged_endpoint(
 56 |             format!("/accounts/{stake_address}/registrations").as_str(),
 57 |             pagination,
 58 |         )
 59 |         .await
 60 |     }
 61 | 
 62 |     pub async fn accounts_withdrawals(
 63 |         &self, stake_address: &str, pagination: Pagination,
 64 |     ) -> BlockfrostResult<Vec<AccountWithdrawalContentInner>> {
 65 |         self.call_paged_endpoint(
 66 |             format!("/accounts/{stake_address}/withdrawals").as_str(),
 67 |             pagination,
 68 |         )
 69 |         .await
 70 |     }
 71 | 
 72 |     pub async fn accounts_mirs(
 73 |         &self, stake_address: &str, pagination: Pagination,
 74 |     ) -> BlockfrostResult<Vec<AccountMirContentInner>> {
 75 |         self.call_paged_endpoint(
 76 |             format!("/accounts/{stake_address}/mirs").as_str(),
 77 |             pagination,
 78 |         )
 79 |         .await
 80 |     }
 81 | 
 82 |     pub async fn accounts_addresses(
 83 |         &self, stake_address: &str, pagination: Pagination,
 84 |     ) -> BlockfrostResult<Vec<AccountAddressesContentInner>> {
 85 |         self.call_paged_endpoint(
 86 |             format!("/accounts/{stake_address}/addresses",).as_str(),
 87 |             pagination,
 88 |         )
 89 |         .await
 90 |     }
 91 | 
 92 |     pub async fn accounts_addresses_assets(
 93 |         &self, stake_address: &str, pagination: Pagination,
 94 |     ) -> BlockfrostResult<Vec<AccountAddressesAssetsInner>> {
 95 |         self.call_paged_endpoint(
 96 |             format!("/accounts/{stake_address}/addresses/assets").as_str(),
 97 |             pagination,
 98 |         )
 99 |         .await
100 |     }
101 | 
102 |     pub async fn accounts_addresses_total(
103 |         &self, stake_address: &str,
104 |     ) -> BlockfrostResult<AccountAddressesTotal> {
105 |         self.call_endpoint(format!("/accounts/{stake_address}/addresses/total").as_str())
106 |             .await
107 |     }
108 | }
109 | #[cfg(test)]
110 | mod tests {
111 |     use super::*;
112 |     use serde_json::json;
113 | 
114 |     #[tokio::test]
115 |     async fn test_accounts() {
116 |         let json_value = json!({
117 |             "stake_address": "stake1ux3g2c9dx2nhhehyrezyxpkstartcqmu9hk63qgfkccw5rqttygt7",
118 |             "active": true,
119 |             "active_epoch": 412,
120 |             "controlled_amount": "619154618165",
121 |             "rewards_sum": "319154618165",
122 |             "withdrawals_sum": "12125369253",
123 |             "reserves_sum": "319154618165",
124 |             "treasury_sum": "12000000",
125 |             "withdrawable_amount": "319154618165",
126 |             "pool_id": "pool1pu5jlj4q9w9jlxeu370a3c9myx47md5j5m2str0naunn2q3lkdy",
127 |             "drep_id": "drep124w9k5ml25kcshqet8r3g2pwk6kqdhj79thg2rphf5u5urve0an"
128 |         });
129 | 
130 |         serde_json::from_value::<AccountContent>(json_value).unwrap();
131 |     }
132 | 
133 |     #[tokio::test]
134 |     async fn test_account_reward() {
135 |         let json_value = json!([
136 |             {
137 |                 "epoch": 215,
138 |                 "amount": "12695385",
139 |                 "pool_id": "pool1pu5jlj4q9w9jlxeu370a3c9myx47md5j5m2str0naunn2q3lkdy",
140 |                 "type": "leader"
141 |             },
142 |             {
143 |                 "epoch": 216,
144 |                 "amount": "3586329",
145 |                 "pool_id": "pool1pu5jlj4q9w9jlxeu370a3c9myx47md5j5m2str0naunn2q3lkdy",
146 |                 "type": "leader"
147 |             },
148 |             {
149 |                 "epoch": 217,
150 |                 "amount": "0",
151 |                 "pool_id": "pool1pu5jlj4q9w9jlxeu370a3c9myx47md5j5m2str0naunn2q3lkdy",
152 |                 "type": "leader"
153 |             },
154 |             {
155 |                 "epoch": 218,
156 |                 "amount": "1395265",
157 |                 "pool_id": "pool1pu5jlj4q9w9jlxeu370a3c9myx47md5j5m2str0naunn2q3lkdy",
158 |                 "type": "leader"
159 |             }
160 |         ]);
161 | 
162 |         serde_json::from_value::<Vec<AccountRewardContentInner>>(json_value).unwrap();
163 |     }
164 | 
165 |     #[tokio::test]
166 |     async fn test_account_history() {
167 |         let json_value = json!([
168 |             {
169 |                 "active_epoch": 210,
170 |                 "amount": "12695385",
171 |                 "pool_id": "pool1pu5jlj4q9w9jlxeu370a3c9myx47md5j5m2str0naunn2q3lkdy"
172 |             },
173 |             {
174 |                 "active_epoch": 211,
175 |                 "amount": "22695385",
176 |                 "pool_id": "pool1pu5jlj4q9w9jlxeu370a3c9myx47md5j5m2str0naunn2q3lkdy"
177 |             }
178 |         ]);
179 | 
180 |         serde_json::from_value::<Vec<AccountHistoryContentInner>>(json_value).unwrap();
181 |     }
182 | 
183 |     #[tokio::test]
184 |     async fn test_account_delegation() {
185 |         let json_value = json!([
186 |             {
187 |                 "active_epoch": 210,
188 |                 "tx_hash": "2dd15e0ef6e6a17841cb9541c27724072ce4d4b79b91e58432fbaa32d9572531",
189 |                 "amount": "12695385",
190 |                 "pool_id": "pool1pu5jlj4q9w9jlxeu370a3c9myx47md5j5m2str0naunn2q3lkdy"
191 |             },
192 |             {
193 |                 "active_epoch": 242,
194 |                 "tx_hash": "1a0570af966fb355a7160e4f82d5a80b8681b7955f5d44bec0dde628516157f0",
195 |                 "amount": "12691385",
196 |                 "pool_id": "pool1kchver88u3kygsak8wgll7htr8uxn5v35lfrsyy842nkscrzyvj"
197 |             }
198 |         ]);
199 | 
200 |         serde_json::from_value::<Vec<AccountDelegationContentInner>>(json_value).unwrap();
201 |     }
202 | 
203 |     #[tokio::test]
204 |     async fn test_account_registration() {
205 |         let json_value = json!([
206 |             {
207 |                 "tx_hash": "2dd15e0ef6e6a17841cb9541c27724072ce4d4b79b91e58432fbaa32d9572531",
208 |                 "action": "registered"
209 |             },
210 |             {
211 |                 "tx_hash": "1a0570af966fb355a7160e4f82d5a80b8681b7955f5d44bec0dde628516157f0",
212 |                 "action": "deregistered"
213 |             }
214 |         ]);
215 | 
216 |         serde_json::from_value::<Vec<AccountRegistrationContentInner>>(json_value).unwrap();
217 |     }
218 | 
219 |     #[tokio::test]
220 |     async fn test_account_withdrawal() {
221 |         let json_value = json!([
222 |             {
223 |                 "tx_hash": "48a9625c841eea0dd2bb6cf551eabe6523b7290c9ce34be74eedef2dd8f7ecc5",
224 |                 "amount": "454541212442"
225 |             },
226 |             {
227 |                 "tx_hash": "4230b0cbccf6f449f0847d8ad1d634a7a49df60d8c142bb8cc2dbc8ca03d9e34",
228 |                 "amount": "97846969"
229 |             }
230 |         ]);
231 | 
232 |         serde_json::from_value::<Vec<AccountWithdrawalContentInner>>(json_value).unwrap();
233 |     }
234 | 
235 |     #[tokio::test]
236 |     async fn test_account_mir() {
237 |         let json_value = json!([
238 |             {
239 |                 "tx_hash": "48a9625c841eea0dd2bb6cf551eabe6523b7290c9ce34be74eedef2dd8f7ecc5",
240 |                 "amount": "454541212442"
241 |             },
242 |             {
243 |                 "tx_hash": "4230b0cbccf6f449f0847d8ad1d634a7a49df60d8c142bb8cc2dbc8ca03d9e34",
244 |                 "amount": "97846969"
245 |             }
246 |         ]);
247 | 
248 |         serde_json::from_value::<Vec<AccountMirContentInner>>(json_value).unwrap();
249 |     }
250 | 
251 |     #[tokio::test]
252 |     async fn test_account_address() {
253 |         let json_value = json!([
254 |             {
255 |                 "address": "addr1qx2kd28nq8ac5prwg32hhvudlwggpgfp8utlyqxu6wqgz62f79qsdmm5dsknt9ecr5w468r9ey0fxwkdrwh08ly3tu9sy0f4qd"
256 |             },
257 |             {
258 |                 "address": "addr1qys3czp8s9thc6u2fqed9yq3h24nyw28uk0m6mkgn9dkckjf79qsdmm5dsknt9ecr5w468r9ey0fxwkdrwh08ly3tu9suth4w4"
259 |             },
260 |             {
261 |                 "address": "addr1q8j55h253zcvl326sk5qdt2n8z7eghzspe0ekxgncr796s2f79qsdmm5dsknt9ecr5w468r9ey0fxwkdrwh08ly3tu9sjmd35m"
262 |             },
263 |             {
264 |                 "address": "addr1q8f7gxrprank3drhx8k5grlux7ene0nlwun8y9thu8mc3yjf79qsdmm5dsknt9ecr5w468r9ey0fxwkdrwh08ly3tu9sls6vnt"
265 |             }
266 |         ]);
267 | 
268 |         serde_json::from_value::<Vec<AccountAddressesContentInner>>(json_value).unwrap();
269 |     }
270 | 
271 |     #[tokio::test]
272 |     async fn test_account_address_asset() {
273 |         let json_value = json!([
274 |             {
275 |                 "unit": "d5e6bf0500378d4f0da4e8dde6becec7621cd8cbf5cbb9b87013d4cc537061636542756433343132",
276 |                 "quantity": "1"
277 |             },
278 |             {
279 |                 "unit": "b0d07d45fe9514f80213f4020e5a61241458be626841cde717cb38a76e7574636f696e",
280 |                 "quantity": "125"
281 |             }
282 |         ]);
283 | 
284 |         serde_json::from_value::<Vec<AccountAddressesAssetsInner>>(json_value).unwrap();
285 |     }
286 | }
287 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                                  Apache License
  2 |                            Version 2.0, January 2004
  3 |                         http://www.apache.org/licenses/
  4 | 
  5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
  6 | 
  7 | 1. Definitions.
  8 | 
  9 |    "License" shall mean the terms and conditions for use, reproduction,
 10 |    and distribution as defined by Sections 1 through 9 of this document.
 11 | 
 12 |    "Licensor" shall mean the copyright owner or entity authorized by
 13 |    the copyright owner that is granting the License.
 14 | 
 15 |    "Legal Entity" shall mean the union of the acting entity and all
 16 |    other entities that control, are controlled by, or are under common
 17 |    control with that entity. For the purposes of this definition,
 18 |    "control" means (i) the power, direct or indirect, to cause the
 19 |    direction or management of such entity, whether by contract or
 20 |    otherwise, or (ii) ownership of fifty percent (50%) or more of the
 21 |    outstanding shares, or (iii) beneficial ownership of such entity.
 22 | 
 23 |    "You" (or "Your") shall mean an individual or Legal Entity
 24 |    exercising permissions granted by this License.
 25 | 
 26 |    "Source" form shall mean the preferred form for making modifications,
 27 |    including but not limited to software source code, documentation
 28 |    source, and configuration files.
 29 | 
 30 |    "Object" form shall mean any form resulting from mechanical
 31 |    transformation or translation of a Source form, including but
 32 |    not limited to compiled object code, generated documentation,
 33 |    and conversions to other media types.
 34 | 
 35 |    "Work" shall mean the work of authorship, whether in Source or
 36 |    Object form, made available under the License, as indicated by a
 37 |    copyright notice that is included in or attached to the work
 38 |    (an example is provided in the Appendix below).
 39 | 
 40 |    "Derivative Works" shall mean any work, whether in Source or Object
 41 |    form, that is based on (or derived from) the Work and for which the
 42 |    editorial revisions, annotations, elaborations, or other modifications
 43 |    represent, as a whole, an original work of authorship. For the purposes
 44 |    of this License, Derivative Works shall not include works that remain
 45 |    separable from, or merely link (or bind by name) to the interfaces of,
 46 |    the Work and Derivative Works thereof.
 47 | 
 48 |    "Contribution" shall mean any work of authorship, including
 49 |    the original version of the Work and any modifications or additions
 50 |    to that Work or Derivative Works thereof, that is intentionally
 51 |    submitted to Licensor for inclusion in the Work by the copyright owner
 52 |    or by an individual or Legal Entity authorized to submit on behalf of
 53 |    the copyright owner. For the purposes of this definition, "submitted"
 54 |    means any form of electronic, verbal, or written communication sent
 55 |    to the Licensor or its representatives, including but not limited to
 56 |    communication on electronic mailing lists, source code control systems,
 57 |    and issue tracking systems that are managed by, or on behalf of, the
 58 |    Licensor for the purpose of discussing and improving the Work, but
 59 |    excluding communication that is conspicuously marked or otherwise
 60 |    designated in writing by the copyright owner as "Not a Contribution."
 61 | 
 62 |    "Contributor" shall mean Licensor and any individual or Legal Entity
 63 |    on behalf of whom a Contribution has been received by Licensor and
 64 |    subsequently incorporated within the Work.
 65 | 
 66 | 2. Grant of Copyright License. Subject to the terms and conditions of
 67 |    this License, each Contributor hereby grants to You a perpetual,
 68 |    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 69 |    copyright license to reproduce, prepare Derivative Works of,
 70 |    publicly display, publicly perform, sublicense, and distribute the
 71 |    Work and such Derivative Works in Source or Object form.
 72 | 
 73 | 3. Grant of Patent License. Subject to the terms and conditions of
 74 |    this License, each Contributor hereby grants to You a perpetual,
 75 |    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 76 |    (except as stated in this section) patent license to make, have made,
 77 |    use, offer to sell, sell, import, and otherwise transfer the Work,
 78 |    where such license applies only to those patent claims licensable
 79 |    by such Contributor that are necessarily infringed by their
 80 |    Contribution(s) alone or by combination of their Contribution(s)
 81 |    with the Work to which such Contribution(s) was submitted. If You
 82 |    institute patent litigation against any entity (including a
 83 |    cross-claim or counterclaim in a lawsuit) alleging that the Work
 84 |    or a Contribution incorporated within the Work constitutes direct
 85 |    or contributory patent infringement, then any patent licenses
 86 |    granted to You under this License for that Work shall terminate
 87 |    as of the date such litigation is filed.
 88 | 
 89 | 4. Redistribution. You may reproduce and distribute copies of the
 90 |    Work or Derivative Works thereof in any medium, with or without
 91 |    modifications, and in Source or Object form, provided that You
 92 |    meet the following conditions:
 93 | 
 94 |    (a) You must give any other recipients of the Work or
 95 |    Derivative Works a copy of this License; and
 96 | 
 97 |    (b) You must cause any modified files to carry prominent notices
 98 |    stating that You changed the files; and
 99 | 
100 |    (c) You must retain, in the Source form of any Derivative Works
101 |    that You distribute, all copyright, patent, trademark, and
102 |    attribution notices from the Source form of the Work,
103 |    excluding those notices that do not pertain to any part of
104 |    the Derivative Works; and
105 | 
106 |    (d) If the Work includes a "NOTICE" text file as part of its
107 |    distribution, then any Derivative Works that You distribute must
108 |    include a readable copy of the attribution notices contained
109 |    within such NOTICE file, excluding those notices that do not
110 |    pertain to any part of the Derivative Works, in at least one
111 |    of the following places: within a NOTICE text file distributed
112 |    as part of the Derivative Works; within the Source form or
113 |    documentation, if provided along with the Derivative Works; or,
114 |    within a display generated by the Derivative Works, if and
115 |    wherever such third-party notices normally appear. The contents
116 |    of the NOTICE file are for informational purposes only and
117 |    do not modify the License. You may add Your own attribution
118 |    notices within Derivative Works that You distribute, alongside
119 |    or as an addendum to the NOTICE text from the Work, provided
120 |    that such additional attribution notices cannot be construed
121 |    as modifying the License.
122 | 
123 |    You may add Your own copyright statement to Your modifications and
124 |    may provide additional or different license terms and conditions
125 |    for use, reproduction, or distribution of Your modifications, or
126 |    for any such Derivative Works as a whole, provided Your use,
127 |    reproduction, and distribution of the Work otherwise complies with
128 |    the conditions stated in this License.
129 | 
130 | 5. Submission of Contributions. Unless You explicitly state otherwise,
131 |    any Contribution intentionally submitted for inclusion in the Work
132 |    by You to the Licensor shall be under the terms and conditions of
133 |    this License, without any additional terms or conditions.
134 |    Notwithstanding the above, nothing herein shall supersede or modify
135 |    the terms of any separate license agreement you may have executed
136 |    with Licensor regarding such Contributions.
137 | 
138 | 6. Trademarks. This License does not grant permission to use the trade
139 |    names, trademarks, service marks, or product names of the Licensor,
140 |    except as required for reasonable and customary use in describing the
141 |    origin of the Work and reproducing the content of the NOTICE file.
142 | 
143 | 7. Disclaimer of Warranty. Unless required by applicable law or
144 |    agreed to in writing, Licensor provides the Work (and each
145 |    Contributor provides its Contributions) on an "AS IS" BASIS,
146 |    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
147 |    implied, including, without limitation, any warranties or conditions
148 |    of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
149 |    PARTICULAR PURPOSE. You are solely responsible for determining the
150 |    appropriateness of using or redistributing the Work and assume any
151 |    risks associated with Your exercise of permissions under this License.
152 | 
153 | 8. Limitation of Liability. In no event and under no legal theory,
154 |    whether in tort (including negligence), contract, or otherwise,
155 |    unless required by applicable law (such as deliberate and grossly
156 |    negligent acts) or agreed to in writing, shall any Contributor be
157 |    liable to You for damages, including any direct, indirect, special,
158 |    incidental, or consequential damages of any character arising as a
159 |    result of this License or out of the use or inability to use the
160 |    Work (including but not limited to damages for loss of goodwill,
161 |    work stoppage, computer failure or malfunction, or any and all
162 |    other commercial damages or losses), even if such Contributor
163 |    has been advised of the possibility of such damages.
164 | 
165 | 9. Accepting Warranty or Additional Liability. While redistributing
166 |    the Work or Derivative Works thereof, You may choose to offer,
167 |    and charge a fee for, acceptance of support, warranty, indemnity,
168 |    or other liability obligations and/or rights consistent with this
169 |    License. However, in accepting such obligations, You may act only
170 |    on Your own behalf and on Your sole responsibility, not on behalf
171 |    of any other Contributor, and only if You agree to indemnify,
172 |    defend, and hold each Contributor harmless for any liability
173 |    incurred by, or claims asserted against, such Contributor by reason
174 |    of your accepting any such warranty or additional liability.
175 | 
176 | END OF TERMS AND CONDITIONS
177 | 
178 | APPENDIX: How to apply the Apache License to your work.
179 | 
180 |       To apply the Apache License to your work, attach the following
181 |       boilerplate notice, with the fields enclosed by brackets "[]"
182 |       replaced with your own identifying information. (Don't include
183 |       the brackets!)  The text should be enclosed in the appropriate
184 |       comment syntax for the file format. We also recommend that a
185 |       file or class name and description of purpose be included on the
186 |       same "printed page" as the copyright notice for easier
187 |       identification within third-party archives.
188 | 
189 | Copyright [yyyy] [name of copyright owner]
190 | 
191 | Licensed under the Apache License, Version 2.0 (the "License");
192 | you may not use this file except in compliance with the License.
193 | You may obtain a copy of the License at
194 | 
195 |        http://www.apache.org/licenses/LICENSE-2.0
196 | 
197 | Unless required by applicable law or agreed to in writing, software
198 | distributed under the License is distributed on an "AS IS" BASIS,
199 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
200 | See the License for the specific language governing permissions and
201 | limitations under the License.
202 | 


--------------------------------------------------------------------------------
/src/ipfs.rs:
--------------------------------------------------------------------------------
  1 | use crate::{
  2 |     error::{json_error, process_error_response, reqwest_error},
  3 |     request::{send_request, send_request_unprocessed},
  4 |     utils::{build_header_map, create_client_with_project_id},
  5 |     BlockfrostError, Integer, IpfsSettings, RetrySettings, IPFS_URL,
  6 | };
  7 | use blockfrost_openapi::models::_ipfs_pin_list__ipfs_path__get_200_response::IpfsPinListIpfsPathGet200Response;
  8 | use reqwest::{
  9 |     multipart::{Form, Part},
 10 |     ClientBuilder,
 11 | };
 12 | use serde::{Deserialize, Serialize};
 13 | use serde_json::from_str as json_from;
 14 | 
 15 | /// Provides methods for making requests to the
 16 | /// [IPFS API](https://docs.blockfrost.io/#tag/IPFS-Add).
 17 | #[derive(Debug, Clone)]
 18 | pub struct BlockfrostIPFS {
 19 |     pub base_url: String,
 20 |     client: reqwest::Client,
 21 |     pub settings: IpfsSettings,
 22 | }
 23 | 
 24 | impl BlockfrostIPFS {
 25 |     /// Create a [`IpfsApi`] with [`custom settings`](IpfsSettings).
 26 |     ///
 27 |     /// # Panics
 28 |     ///
 29 |     /// This function might panic if `project_id` could not be converted into a [`HeaderValue`] with
 30 |     /// the function [`HeaderValue::from_str`].
 31 |     ///
 32 |     /// [`HeaderValue`]: reqwest::header::HeaderValue
 33 |     /// [`HeaderValue::from_str`]: reqwest::header::HeaderValue::from_str
 34 |     pub fn new(project_id: &str, settings: IpfsSettings) -> Self {
 35 |         let client = create_client_with_project_id(project_id, &settings.headers);
 36 | 
 37 |         Self {
 38 |             client,
 39 |             settings,
 40 |             base_url: IPFS_URL.to_string(),
 41 |         }
 42 |     }
 43 | 
 44 |     /// Create a [`IpfsApi`] with [custom settings](IpfsSettings) and [custom client](ClientBuilder).
 45 |     ///
 46 |     /// This function is a more flexible version of [`IpfsApi::new`], you can customize every
 47 |     /// field of the [`ClientBuilder`] argument, however, note that the [`HeaderMap`] will be
 48 |     /// [overwritten](ClientBuilder::default_headers) by a map with the given `project_id`.
 49 |     ///
 50 |     /// If `client_builder` argument is equivalent to `Client::builder()` or `ClientBuilder::new()`,
 51 |     /// this function returns the same as [`IpfsApi::new`] without the extra argument.
 52 |     ///
 53 |     /// # Panics
 54 |     ///
 55 |     /// This function might panic if `project_id` could not be converted into a [`HeaderValue`] with
 56 |     /// the function [`HeaderValue::from_str`].
 57 |     ///
 58 |     /// [`HeaderMap`]: reqwest::header::HeaderMap
 59 |     /// [`HeaderValue`]: reqwest::header::HeaderValue
 60 |     /// [`HeaderValue::from_str`]: reqwest::header::HeaderValue::from_str
 61 |     pub fn new_with_client(
 62 |         project_id: impl AsRef<str>, settings: IpfsSettings, client_builder: ClientBuilder,
 63 |     ) -> reqwest::Result<Self> {
 64 |         client_builder
 65 |             .default_headers(build_header_map(project_id.as_ref(), &settings.headers))
 66 |             .build()
 67 |             .map(|client| Self {
 68 |                 settings,
 69 |                 client,
 70 |                 base_url: IPFS_URL.to_string(),
 71 |             })
 72 |     }
 73 | 
 74 |     /// Adding a file to `IPFS`.
 75 |     ///
 76 |     /// Note that you need to `/ipfs/pin/add` an object to avoid it being garbage collected.
 77 |     ///
 78 |     /// This usage is being counted in your user account quota.
 79 |     ///
 80 |     /// OpenAPI endpoint reference: [`/ipfs/add`].
 81 |     ///
 82 |     /// [`/ipfs/add`]: https://docs.blockfrost.io/#tag/IPFS-Add/paths/~1ipfs~1add/post
 83 |     pub async fn add(&self, file_contents: Vec<u8>) -> Result<IpfsAdd, BlockfrostError> {
 84 |         let url = self.base_url.clone() + "/ipfs/add";
 85 | 
 86 |         let part = Part::bytes(file_contents);
 87 |         let form = Form::new().part("file", part);
 88 | 
 89 |         let request = self.client.post(&url).multipart(form);
 90 | 
 91 |         let (status, text) = send_request(request, self.settings.retry_settings)
 92 |             .await
 93 |             .map_err(|reason| reqwest_error(&url, reason))?;
 94 | 
 95 |         if !status.is_success() {
 96 |             return Err(process_error_response(&text, status, &url));
 97 |         }
 98 | 
 99 |         json_from(&text).map_err(|reason| json_error(url, text, reason))
100 |     }
101 | 
102 |     /// Retrieve an object from the IFPS gateway.
103 |     ///
104 |     /// Useful if you do not want to rely on a public gateway, such as <ipfs.blockfrost.dev>.
105 |     ///
106 |     /// OpenAPI endpoint reference: [`/ipfs/gateway/{IPFS_path}`].
107 |     ///
108 |     /// [`/ipfs/gateway/{IPFS_path}`]: https://docs.blockfrost.io/#tag/IPFS-Gateway
109 |     pub async fn gateway(&self, ipfs_path: &str) -> Result<Vec<u8>, BlockfrostError> {
110 |         let url = self.base_url.clone() + &format!("/ipfs/gateway/{ipfs_path}");
111 | 
112 |         let request = self.client.get(&url);
113 | 
114 |         let response = send_request_unprocessed(request, self.retry_settings())
115 |             .await
116 |             .map_err(|reason| reqwest_error(&url, reason))?;
117 |         let status = response.status();
118 | 
119 |         if !status.is_success() {
120 |             let text = response
121 |                 .text()
122 |                 .await
123 |                 .map_err(|reason| reqwest_error(&url, reason))?;
124 |             Err(process_error_response(&text, status, &url))
125 |         } else {
126 |             let bytes = response
127 |                 .bytes()
128 |                 .await
129 |                 .map_err(|reason| reqwest_error(&url, reason))?;
130 |             Ok(bytes.to_vec())
131 |         }
132 |     }
133 | 
134 |     /// Pinned objects are counted in your user storage quota.
135 |     ///
136 |     /// OpenAPI endpoint reference: [`/ipfs/pin/add/{IPFS_path}`].
137 |     ///
138 |     /// [`/ipfs/pin/add/{IPFS_path}`]: https://docs.blockfrost.io/#tag/IPFS-Pins/paths/~1ipfs~1pin~1add~1{IPFS_path}/post
139 |     pub async fn pin_add(&self, ipfs_path: &str) -> Result<IpfsPinUpdate, BlockfrostError> {
140 |         let url = self.base_url.clone() + &format!("/ipfs/pin/add/{ipfs_path}");
141 | 
142 |         let request = self.client.post(&url);
143 |         let (status, text) = send_request(request, self.settings.retry_settings)
144 |             .await
145 |             .map_err(|reason| reqwest_error(&url, reason))?;
146 |         if !status.is_success() {
147 |             return Err(process_error_response(&text, status, &url));
148 |         }
149 | 
150 |         json_from(&text).map_err(|reason| json_error(url, text, reason))
151 |     }
152 | 
153 |     /// List objects pinned to local storage.
154 |     ///
155 |     /// OpenAPI endpoint reference: [`/ipfs/pin/list`].
156 |     ///
157 |     /// [`/ipfs/pin/list`]: https://docs.blockfrost.io/#tag/IPFS-Pins/paths/~1ipfs~1pin~1list~1/get
158 |     pub async fn pin_list(
159 |         &self,
160 |     ) -> Result<Vec<IpfsPinListIpfsPathGet200Response>, BlockfrostError> {
161 |         let url = self.base_url.clone() + "/ipfs/pin/list";
162 | 
163 |         let request = self.client.get(&url);
164 |         let (status, text) = send_request(request, self.settings.retry_settings)
165 |             .await
166 |             .map_err(|reason| reqwest_error(&url, reason))?;
167 | 
168 |         if !status.is_success() {
169 |             return Err(process_error_response(&text, status, &url));
170 |         }
171 | 
172 |         json_from(&text).map_err(|reason| json_error(url, text, reason))
173 |     }
174 | 
175 |     /// Get information about locally pinned IPFS object.
176 |     ///
177 |     /// OpenAPI endpoint reference: [`/ipfs/pin/list/{IPFS_path}`].
178 |     ///
179 |     /// [`/ipfs/pin/list/{IPFS_path}`]: https://docs.blockfrost.io/#tag/IPFS-Pins/paths/~1ipfs~1pin~1list~1{IPFS_path}/get
180 |     pub async fn pin_list_by_id(&self, ipfs_path: &str) -> Result<IpfsPinList, BlockfrostError> {
181 |         let url = self.base_url.clone() + &format!("/ipfs/pin/list/{ipfs_path}");
182 | 
183 |         let request = self.client.get(&url);
184 |         let (status, text) = send_request(request, self.settings.retry_settings)
185 |             .await
186 |             .map_err(|reason| reqwest_error(&url, reason))?;
187 | 
188 |         if !status.is_success() {
189 |             return Err(process_error_response(&text, status, &url));
190 |         }
191 | 
192 |         json_from(&text).map_err(|reason| json_error(url, text, reason))
193 |     }
194 | 
195 |     /// Remove pinned objects from local storage.
196 |     ///
197 |     /// OpenAPI endpoint reference: [`/ipfs/pin/remove/{IPFS_path}`].
198 |     ///
199 |     /// [`/ipfs/pin/remove/{IPFS_path}`]: https://docs.blockfrost.io/#tag/IPFS-Pins/paths/~1ipfs~1pin~1remove~1{IPFS_path}/post
200 |     pub async fn pin_remove(&self, ipfs_path: &str) -> Result<IpfsPinUpdate, BlockfrostError> {
201 |         let url = self.base_url.clone() + &format!("/ipfs/pin/remove/{ipfs_path}");
202 | 
203 |         let request = self.client.post(&url);
204 |         let (status, text) = send_request(request, self.settings.retry_settings)
205 |             .await
206 |             .map_err(|reason| reqwest_error(&url, reason))?;
207 | 
208 |         if !status.is_success() {
209 |             return Err(process_error_response(&text, status, &url));
210 |         }
211 | 
212 |         json_from(&text).map_err(|reason| json_error(url, text, reason))
213 |     }
214 | 
215 |     pub(crate) fn retry_settings(&self) -> RetrySettings {
216 |         self.settings.retry_settings
217 |     }
218 | }
219 | 
220 | /// Created by [`add`](IpfsApi::add) method.
221 | #[derive(Clone, Debug, Serialize, Deserialize)]
222 | pub struct IpfsAdd {
223 |     /// Name of the file.
224 |     pub name: String,
225 |     /// IPFS hash of the file.
226 |     pub ipfs_hash: String,
227 |     /// IPFS node size in Bytes.
228 |     pub size: String,
229 | }
230 | 
231 | /// Created by [`pin_add`](IpfsApi::pin_add) method.
232 | #[derive(Clone, Debug, Serialize, Deserialize)]
233 | pub struct IpfsPinUpdate {
234 |     /// IPFS hash of the pinned object.
235 |     pub ipfs_hash: String,
236 |     /// State of the pin action.
237 |     pub state: IpfsPinState,
238 | }
239 | 
240 | /// Created by [`pin_list`](IpfsApi::pin_list) method.
241 | #[derive(Clone, Debug, Serialize, Deserialize)]
242 | pub struct IpfsPinList {
243 |     /// Creation time of the IPFS object on our backends.
244 |     pub time_created: Integer,
245 |     /// Pin time of the IPFS object on our backends.
246 |     pub time_pinned: Integer,
247 |     /// IPFS hash of the pinned object.
248 |     pub ipfs_hash: String,
249 |     /// Size of the object in Bytes.
250 |     pub size: String,
251 |     /// State of the pinned object, which is `queued` when we are retriving object. If this is
252 |     /// successful the state is changed to `pinned` or `failed` if not. The state `gc` means the
253 |     /// pinned item has been garbage collected due to account being over storage quota or after it
254 |     /// has been moved to `unpinned` state by removing the object pin.
255 |     pub state: IpfsPinState,
256 | }
257 | 
258 | /// Inner enum for [`IpfsPinUpdate`].
259 | #[derive(Serialize, Deserialize, Debug, Clone)]
260 | #[serde(rename_all = "snake_case")]
261 | pub enum IpfsPinState {
262 |     Queued,
263 |     Pinned,
264 |     Unpinned,
265 |     Failed,
266 |     Gc,
267 | }
268 | 
269 | // #[cfg(test)]
270 | // mod tests {
271 | //     use super::*;
272 | 
273 | //     test_example! { test_ipfs_add, IpfsAdd, r#"
274 | //     {
275 | //       "name": "README.md",
276 | //       "ipfs_hash": "QmZbHqiCxKEVX7QfijzJTkZiSi3WEVTcvANgNAWzDYgZDr",
277 | //       "size": "125297"
278 | //     }
279 | //     "# }
280 | 
281 | //     test_example! { test_ipfs_pin_add, IpfsPinUpdate, r#"
282 | //     {
283 | //       "ipfs_hash": "QmPojRfAXYAXV92Dof7gtSgaVuxEk64xx9CKvprqu9VwA8",
284 | //       "state": "queued"
285 | //     }
286 | //     "# }
287 | 
288 | //     test_example! { test_ipfs_pin_list_by_id, IpfsPinList, r#"
289 | //     {
290 | //       "time_created": 1615551024,
291 | //       "time_pinned": 1615551024,
292 | //       "ipfs_hash": "QmdVMnULrY95mth2XkwjxDtMHvzuzmvUPTotKE1tgqKbCx",
293 | //       "size": "1615551024",
294 | //       "state": "pinned"
295 | //     }
296 | //     "# }
297 | // }
298 | 


--------------------------------------------------------------------------------
/src/api/endpoints/transactions.rs:
--------------------------------------------------------------------------------
  1 | use crate::{request::send_request, url::Url, *};
  2 | use blockfrost_openapi::models::{
  3 |     tx_content::TxContent, tx_content_cbor::TxContentCbor,
  4 |     tx_content_delegations_inner::TxContentDelegationsInner,
  5 |     tx_content_metadata_cbor_inner::TxContentMetadataCborInner,
  6 |     tx_content_metadata_inner::TxContentMetadataInner, tx_content_mirs_inner::TxContentMirsInner,
  7 |     tx_content_pool_retires_inner::TxContentPoolRetiresInner,
  8 |     tx_content_redeemers_inner::TxContentRedeemersInner,
  9 |     tx_content_stake_addr_inner::TxContentStakeAddrInner, tx_content_utxo::TxContentUtxo,
 10 |     tx_content_withdrawals_inner::TxContentWithdrawalsInner,
 11 | };
 12 | use reqwest::{header::HeaderValue, Body, Method};
 13 | use serde_json::from_str as json_from;
 14 | 
 15 | impl BlockfrostAPI {
 16 |     /// Obtain information about Move Instantaneous Rewards (MIRs) of a specific transaction.
 17 |     ///
 18 |     /// OpenAPI endpoint reference: [`/accounts/{stake_address}/mirs`].
 19 |     ///
 20 |     /// [`/accounts/{stake_address}/mirs`]: https://docs.blockfrost.io/#tag/Cardano-Transactions/paths/~1tx~1submit/post
 21 |     pub async fn transactions_submit(&self, transaction_data: Vec<u8>) -> BlockfrostResult<String> {
 22 |         let body = Body::from(transaction_data);
 23 |         let endpoint_suffix = "/tx/submit";
 24 |         let url = Url::from_endpoint(self.base_url.as_str(), endpoint_suffix)?;
 25 | 
 26 |         let request = self
 27 |             .client
 28 |             .request(Method::POST, &url)
 29 |             .header("Content-Type", HeaderValue::from_static("application/cbor"))
 30 |             .body(body);
 31 | 
 32 |         let (status, text) = send_request(request, self.settings.retry_settings)
 33 |             .await
 34 |             .map_err(|reason| BlockfrostError::Reqwest {
 35 |                 url: url.clone(),
 36 |                 reason,
 37 |             })?;
 38 | 
 39 |         if !status.is_success() {
 40 |             return Err(process_error_response(&text, status, &url));
 41 |         }
 42 |         json_from(&text).map_err(|reason| json_error(url, text, reason))
 43 |     }
 44 | 
 45 |     pub async fn transaction_by_hash(&self, hash: &str) -> BlockfrostResult<TxContent> {
 46 |         self.call_endpoint(format!("/txs/{hash}").as_str()).await
 47 |     }
 48 | 
 49 |     pub async fn transactions_utxos(&self, hash: &str) -> BlockfrostResult<TxContentUtxo> {
 50 |         self.call_endpoint(format!("/txs/{hash}/utxos").as_str())
 51 |             .await
 52 |     }
 53 | 
 54 |     pub async fn transactions_stakes(
 55 |         &self, hash: &str,
 56 |     ) -> BlockfrostResult<Vec<TxContentStakeAddrInner>> {
 57 |         self.call_endpoint(format!("/txs/{hash}/stakes").as_str())
 58 |             .await
 59 |     }
 60 | 
 61 |     pub async fn transactions_delegations(
 62 |         &self, hash: &str,
 63 |     ) -> BlockfrostResult<Vec<TxContentDelegationsInner>> {
 64 |         self.call_endpoint(format!("/txs/{hash}/delegations").as_str())
 65 |             .await
 66 |     }
 67 | 
 68 |     pub async fn transactions_withdrawals(
 69 |         &self, hash: &str,
 70 |     ) -> BlockfrostResult<Vec<TxContentWithdrawalsInner>> {
 71 |         self.call_endpoint(format!("/txs/{hash}/withdrawals").as_str())
 72 |             .await
 73 |     }
 74 | 
 75 |     pub async fn transactions_mirs(&self, hash: &str) -> BlockfrostResult<Vec<TxContentMirsInner>> {
 76 |         self.call_endpoint(format!("/txs/{hash}/mirs").as_str())
 77 |             .await
 78 |     }
 79 | 
 80 |     pub async fn transactions_pool_updates(
 81 |         &self, hash: &str,
 82 |     ) -> BlockfrostResult<Vec<TxContentMirsInner>> {
 83 |         self.call_endpoint(format!("/txs/{hash}/pool_updates").as_str())
 84 |             .await
 85 |     }
 86 | 
 87 |     pub async fn transactions_pool_retires(
 88 |         &self, hash: &str,
 89 |     ) -> BlockfrostResult<Vec<TxContentPoolRetiresInner>> {
 90 |         self.call_endpoint(format!("/txs/{hash}/pool_retires").as_str())
 91 |             .await
 92 |     }
 93 | 
 94 |     pub async fn transactions_metadata(
 95 |         &self, hash: &str,
 96 |     ) -> BlockfrostResult<Vec<TxContentMetadataInner>> {
 97 |         self.call_endpoint(format!("/txs/{hash}/metadata").as_str())
 98 |             .await
 99 |     }
100 | 
101 |     pub async fn transactions_metadata_cbor(
102 |         &self, hash: &str,
103 |     ) -> BlockfrostResult<Vec<TxContentMetadataCborInner>> {
104 |         self.call_endpoint(format!("/txs/{hash}/metadata/cbor").as_str())
105 |             .await
106 |     }
107 | 
108 |     pub async fn transactions_cbor(&self, hash: &str) -> BlockfrostResult<TxContentCbor> {
109 |         self.call_endpoint(format!("/txs/{hash}/cbor").as_str())
110 |             .await
111 |     }
112 | 
113 |     pub async fn transactions_redeemers(
114 |         &self, hash: &str,
115 |     ) -> BlockfrostResult<Vec<TxContentRedeemersInner>> {
116 |         self.call_endpoint(format!("/txs/{hash}/redeemers").as_str())
117 |             .await
118 |     }
119 | }
120 | #[cfg(test)]
121 | mod tests {
122 |     use super::*;
123 |     use blockfrost_openapi::models::{
124 |         tx_content_metadata_inner_json_metadata::TxContentMetadataInnerJsonMetadata,
125 |         tx_content_utxo::TxContentUtxo,
126 |     };
127 |     use serde_json::json;
128 | 
129 |     #[tokio::test]
130 |     async fn test_transaction() {
131 |         let json_value = json!({
132 |             "hash": "1e043f100dce12d107f679685acd2fc0610e10f72a92d412794c9773d11d8477",
133 |             "block": "356b7d7dbb696ccd12775c016941057a9dc70898d87a63fc752271bb46856940",
134 |             "block_height": 123456,
135 |             "block_time": 2,
136 |             "slot": 42000000,
137 |             "index": 1,
138 |             "output_amount": [
139 |                 {
140 |                     "unit": "lovelace",
141 |                     "quantity": "42000000"
142 |                 },
143 |                 {
144 |                     "unit": "b0d07d45fe9514f80213f4020e5a61241458be626841cde717cb38a76e7574636f696e",
145 |                     "quantity": "12"
146 |                 }
147 |             ],
148 |             "fees": "182485",
149 |             "deposit": "0",
150 |             "size": 433,
151 |             "invalid_before": null,
152 |             "invalid_hereafter": "13885913",
153 |             "utxo_count": 4,
154 |             "withdrawal_count": 0,
155 |             "mir_cert_count": 0,
156 |             "delegation_count": 0,
157 |             "stake_cert_count": 0,
158 |             "pool_update_count": 0,
159 |             "pool_retire_count": 0,
160 |             "asset_mint_or_burn_count": 0,
161 |             "redeemer_count": 0,
162 |             "valid_contract": false
163 |         });
164 |         serde_json::from_value::<TxContent>(json_value).unwrap();
165 |     }
166 | 
167 |     #[tokio::test]
168 |     async fn test_transaction_null_invalid_hereafter() {
169 |         let json_value = json!({
170 |             "hash": "78e5821367cd4e2fbfce4d32c3ecededd388f13118f06b959015c2aad19b5cd8",
171 |             "block": "bb4003096f11eaaca11d3705db62637f311f93671fcb4d4b3cf8749a90ea4b74",
172 |             "block_height": 6352717,
173 |             "block_time": 1633861069,
174 |             "slot": 42294778,
175 |             "index": 9,
176 |             "output_amount": [
177 |                 {
178 |                     "unit": "lovelace",
179 |                     "quantity": "4828735"
180 |                 },
181 |                 {
182 |                     "unit": "29d222ce763455e3d7a09a665ce554f00ac89d2e99a1a83d267170c64d494e",
183 |                     "quantity": "25000000000000"
184 |                 }
185 |             ],
186 |             "fees": "171265",
187 |             "deposit": "0",
188 |             "size": 357,
189 |             "invalid_before": null,
190 |             "invalid_hereafter": null,
191 |             "utxo_count": 3,
192 |             "withdrawal_count": 0,
193 |             "mir_cert_count": 0,
194 |             "delegation_count": 0,
195 |             "stake_cert_count": 0,
196 |             "pool_update_count": 0,
197 |             "pool_retire_count": 0,
198 |             "asset_mint_or_burn_count": 1,
199 |             "redeemer_count": 0,
200 |             "valid_contract": true
201 |         });
202 |         serde_json::from_value::<TxContent>(json_value).unwrap();
203 |     }
204 | 
205 |     #[tokio::test]
206 |     async fn test_transaction_utxos() {
207 |         let json_value = json!({
208 |             "hash": "1e043f100dce12d107f679685acd2fc0610e10f72a92d412794c9773d11d8477",
209 |             "inputs": [
210 |                 {
211 |                     "address": "addr1q9ld26v2lv8wvrxxmvg90pn8n8n5k6tdst06q2s856rwmvnueldzuuqmnsye359fqrk8hwvenjnqultn7djtrlft7jnq7dy7wv",
212 |                     "amount": [
213 |                         {
214 |                             "unit": "lovelace",
215 |                             "quantity": "42000000"
216 |                         },
217 |                         {
218 |                             "unit": "b0d07d45fe9514f80213f4020e5a61241458be626841cde717cb38a76e7574636f696e",
219 |                             "quantity": "12"
220 |                         }
221 |                     ],
222 |                     "inline_datum": "12",
223 |                     "reference_script_hash": "1a0570af966fb355a7160e4f82d5a80b8681b7955f5d44bec0dce628516157f0",
224 |                     "tx_hash": "1a0570af966fb355a7160e4f82d5a80b8681b7955f5d44bec0dce628516157f0",
225 |                     "output_index": 0,
226 |                     "data_hash": null,
227 |                     "collateral": false
228 |                 }
229 |             ],
230 |             "outputs": [
231 |                 {
232 |                     "address": "addr1q9ld26v2lv8wvrxxmvg90pn8n8n5k6tdst06q2s856rwmvnueldzuuqmnsye359fqrk8hwvenjnqultn7djtrlft7jnq7dy7wv",
233 |                     "output_index": 0,
234 |                     "data_hash": null,
235 |                     "reference_script_hash": "1a0570af966fb355a7160e4f82d5a80b8681b7955f5d44bec0dce628516157f0",
236 |                     "inline_datum": null,
237 |                     "collateral": false,
238 |                     "amount": [
239 |                         {
240 |                             "unit": "lovelace",
241 |                             "quantity": "42000000"
242 |                         },
243 |                         {
244 |                             "unit": "b0d07d45fe9514f80213f4020e5a61241458be626841cde717cb38a76e7574636f696e",
245 |                             "quantity": "12"
246 |                         }
247 |                     ]
248 |                 }
249 |             ]
250 |         });
251 | 
252 |         serde_json::from_value::<TxContentUtxo>(json_value).unwrap();
253 |     }
254 | 
255 |     #[tokio::test]
256 |     async fn test_transaction_stakes() {
257 |         let json_value = json!([
258 |             {
259 |                 "cert_index": 0,
260 |                 "address": "stake1u9t3a0tcwune5xrnfjg4q7cpvjlgx9lcv0cuqf5mhfjwrvcwrulda",
261 |                 "registration": true
262 |             }
263 |         ]);
264 | 
265 |         serde_json::from_value::<Vec<TxContentStakeAddrInner>>(json_value).unwrap();
266 |     }
267 | 
268 |     #[tokio::test]
269 |     async fn test_transaction_delegations() {
270 |         let json_value = json!([
271 |             {
272 |                 "index": 0,
273 |                 "cert_index": 0,
274 |                 "address": "stake1u9r76ypf5fskppa0cmttas05cgcswrttn6jrq4yd7jpdnvc7gt0yc",
275 |                 "pool_id": "pool1pu5jlj4q9w9jlxeu370a3c9myx47md5j5m2str0naunn2q3lkdy",
276 |                 "active_epoch": 210
277 |             }
278 |         ]);
279 |         serde_json::from_value::<Vec<TxContentDelegationsInner>>(json_value).unwrap();
280 |     }
281 | 
282 |     #[tokio::test]
283 |     async fn test_transaction_withdrawals() {
284 |         let json_value = json!([
285 |             {
286 |                 "address": "stake1u9r76ypf5fskppa0cmttas05cgcswrttn6jrq4yd7jpdnvc7gt0yc",
287 |                 "amount": "431833601"
288 |             }
289 |         ]);
290 | 
291 |         serde_json::from_value::<Vec<TxContentWithdrawalsInner>>(json_value).unwrap();
292 |     }
293 | 
294 |     #[tokio::test]
295 |     async fn test_transaction_mirs() {
296 |         let json_value = json!([
297 |             {
298 |                 "pot": "reserve",
299 |                 "cert_index": 0,
300 |                 "address": "stake1u9r76ypf5fskppa0cmttas05cgcswrttn6jrq4yd7jpdnvc7gt0yc",
301 |                 "amount": "431833601"
302 |             }
303 |         ]);
304 | 
305 |         serde_json::from_value::<Vec<TxContentMirsInner>>(json_value).unwrap();
306 |     }
307 | 
308 |     #[tokio::test]
309 |     async fn test_transaction_pool_updates() {
310 |         let json_value = json!([
311 |             {
312 |                 "cert_index": 0,
313 |                 "pool_id": "pool1pu5jlj4q9w9jlxeu370a3c9myx47md5j5m2str0naunn2q3lkdy",
314 |                 "vrf_key": "0b5245f9934ec2151116fb8ec00f35fd00e0aa3b075c4ed12cce440f999d8233",
315 |                 "pledge": "5000000000",
316 |                 "margin_cost": 0.05,
317 |                 "fixed_cost": "340000000",
318 |                 "reward_account": "stake1uxkptsa4lkr55jleztw43t37vgdn88l6ghclfwuxld2eykgpgvg3f",
319 |                 "owners": [
320 |                     "stake1u98nnlkvkk23vtvf9273uq7cph5ww6u2yq2389psuqet90sv4xv9v"
321 |                 ],
322 |                 "metadata": {
323 |                     "url": "https://stakenuts.com/mainnet.json",
324 |                     "hash": "47c0c68cb57f4a5b4a87bad896fc274678e7aea98e200fa14a1cb40c0cab1d8c",
325 |                     "ticker": "NUTS",
326 |                     "name": "Stake Nuts",
327 |                     "description": "The best pool ever",
328 |                     "homepage": "https://stakentus.com/"
329 |                 },
330 |                 "relays": [
331 |                     {
332 |                         "ipv4": "4.4.4.4",
333 |                         "ipv6": "https://stakenuts.com/mainnet.json",
334 |                         "dns": "relay1.stakenuts.com",
335 |                         "dns_srv": "_relays._tcp.relays.stakenuts.com",
336 |                         "port": 3001
337 |                     }
338 |                 ],
339 |                 "active_epoch": 210
340 |             }
341 |         ]);
342 | 
343 |         serde_json::from_value::<Vec<TxContentMetadataInnerJsonMetadata>>(json_value).unwrap();
344 |     }
345 | 
346 |     #[tokio::test]
347 |     async fn test_transaction_pool_retires() {
348 |         let json_value = json!([
349 |             {
350 |                 "cert_index": 0,
351 |                 "pool_id": "pool1pu5jlj4q9w9jlxeu370a3c9myx47md5j5m2str0naunn2q3lkdy",
352 |                 "retiring_epoch": 216
353 |             }
354 |         ]);
355 | 
356 |         serde_json::from_value::<Vec<TxContentMetadataInnerJsonMetadata>>(json_value).unwrap();
357 |     }
358 | 
359 |     #[tokio::test]
360 |     async fn test_transaction_metadata() {
361 |         let json_value = json!([
362 |             {
363 |                 "label": "1967",
364 |                 "json_metadata": {
365 |                     "metadata": "https://nut.link/metadata.json",
366 |                     "hash": "6bf124f217d0e5a0a8adb1dbd8540e1334280d49ab861127868339f43b3948af"
367 |                 }
368 |             },
369 |             {
370 |                 "label": "1968",
371 |                 "json_metadata": {
372 |                     "ADAUSD": [
373 |                         {
374 |                             "value": "0.10409800535729975",
375 |                             "source": "ergoOracles"
376 |                         }
377 |                     ]
378 |                 }
379 |             }
380 |         ]);
381 | 
382 |         serde_json::from_value::<Vec<TxContentMetadataInnerJsonMetadata>>(json_value).unwrap();
383 |     }
384 | 
385 |     #[tokio::test]
386 |     async fn test_transaction_metadata_cbor() {
387 |         let json_value = json!([
388 |             {
389 |                 "label": "1968",
390 |                 "cbor_metadata": "\\xa100a16b436f6d62696e6174696f6e8601010101010c",
391 |                 "metadata": null
392 |             }
393 |         ]);
394 | 
395 |         serde_json::from_value::<Vec<TxContentMetadataCborInner>>(json_value).unwrap();
396 |     }
397 | }
398 | 


--------------------------------------------------------------------------------
/examples/all_requests.rs:
--------------------------------------------------------------------------------
  1 | use blockfrost::{BlockFrostSettings, BlockfrostAPI, BlockfrostResult, Pagination};
  2 | 
  3 | fn build_api() -> BlockfrostResult<BlockfrostAPI> {
  4 |     let settings = BlockFrostSettings::new();
  5 |     let api = BlockfrostAPI::new("mainnetxvMK4xOpp5mHJgihi055KDLU64JJv2be", settings);
  6 | 
  7 |     Ok(api)
  8 | }
  9 | 
 10 | #[tokio::main]
 11 | async fn main() -> BlockfrostResult<()> {
 12 |     let api = build_api()?;
 13 |     let pagination = Pagination::default();
 14 |     let tx_data = Vec::from("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");
 15 | 
 16 |     println!("Fetching ...");
 17 | 
 18 |     // Health
 19 |     let root = api.root().await;
 20 |     let health = api.health().await;
 21 |     let health_clock = api.health_clock().await;
 22 | 
 23 |     // Metrics
 24 |     let metrics = api.metrics(pagination).await;
 25 |     let metrics_endpoints = api.metrics_endpoints(pagination).await;
 26 | 
 27 |     // Accounts
 28 |     let address = "stake1u9ylzsgxaa6xctf4juup682ar3juj85n8tx3hthnljg47zctvm3rc";
 29 |     let accounts = api.accounts(address).await;
 30 |     let accounts_rewards = api.accounts_rewards(address, pagination).await;
 31 |     let accounts_history = api.accounts_history(address, pagination).await;
 32 |     let accounts_delegations = api.accounts_delegations(address, pagination).await;
 33 |     let accounts_registrations = api.accounts_registrations(address, pagination).await;
 34 |     let accounts_withdrawals = api.accounts_withdrawals(address, pagination).await;
 35 |     let accounts_mirs = api.accounts_mirs(address, pagination).await;
 36 |     let accounts_addresses = api.accounts_addresses(address, pagination).await;
 37 |     let accounts_addresses_assets = api.accounts_addresses_assets(address, pagination).await;
 38 |     let accounts_addresses_total = api.accounts_addresses_total(address).await;
 39 | 
 40 |     // Addresses
 41 |     let address =
 42 |         "addr1qxqs59lphg8g6qndelq8xwqn60ag3aeyfcp33c2kdp46a09re5df3pzwwmyq946axfcejy5n4x0y99wqpgtp2gd0k09qsgy6pz";
 43 |     let addresses = api.addresses(address).await;
 44 |     let addresses_total = api.addresses_total(address).await;
 45 |     let addresses_utxos = api.addresses_utxos(address, pagination).await;
 46 |     let addresses_transactions = api.addresses_transactions(address, pagination).await;
 47 | 
 48 |     // Assets
 49 |     let asset_name = "6e7574636f696e";
 50 |     let policy_id = "00000002df633853f6a47465c9496721d2d5b1291b8398016c0e87ae";
 51 |     let asset = asset_name.to_string() + policy_id;
 52 |     let assets = api.assets(pagination).await;
 53 |     let assets_by_id = api.assets_by_id(&asset).await;
 54 |     let assets_history = api.assets_history(&asset, pagination).await;
 55 |     let assets_transactions = api.assets_transactions(&asset, pagination).await;
 56 |     let assets_addresses = api.assets_addresses(&asset, pagination).await;
 57 |     let assets_policy_by_id = api.assets_policy_by_id(policy_id, pagination).await;
 58 | 
 59 |     // Epochs
 60 |     let epoch = 225;
 61 |     let pool_id = "pool1pu5jlj4q9w9jlxeu370a3c9myx47md5j5m2str0naunn2q3lkdy";
 62 |     let epochs_latest = api.epochs_latest().await;
 63 |     let epochs_latest_parameters = api.epochs_latest_parameters().await;
 64 |     let epochs_by_number = api.epochs_by_number(epoch).await;
 65 |     let epochs_next = api.epochs_next(epoch, pagination).await;
 66 |     let epochs_previous = api.epochs_previous(epoch, pagination).await;
 67 |     let epochs_stakes = api.epochs_stakes(epoch, pagination).await;
 68 |     let epochs_stakes_by_pool = api.epochs_stakes_by_pool(epoch, pool_id, pagination).await;
 69 |     let epochs_blocks = api.epochs_blocks(epoch).await;
 70 |     let epochs_blocks_by_pool = api.epochs_blocks_by_pool(epoch, pool_id).await;
 71 |     let epochs_parameters = api.epochs_parameters(epoch).await;
 72 | 
 73 |     // Pools
 74 |     let pools = api.pools(pagination).await;
 75 |     let pools_retired = api.pools_retired(pagination).await;
 76 |     let pools_retiring = api.pools_retiring(pagination).await;
 77 |     let pools_by_id = api.pools_by_id(pool_id).await;
 78 |     let pools_history = api.pools_history(pool_id, pagination).await;
 79 |     let pools_metadata = api.pools_metadata(pool_id).await;
 80 |     let pools_relays = api.pools_relays(pool_id).await;
 81 |     let pools_delegators = api.pools_delegators(pool_id, pagination).await;
 82 |     let pools_blocks = api.pools_blocks(pool_id, pagination).await;
 83 |     let pools_updates = api.pools_updates(pool_id, pagination).await;
 84 | 
 85 |     // Blocks
 86 |     let block = "4874756";
 87 |     let slot = 12268658;
 88 |     let blocks_latest = api.blocks_latest().await;
 89 |     let blocks_latest_txs = api.blocks_latest_txs(pagination).await;
 90 |     let blocks_by_id = api.blocks_by_id(block).await;
 91 |     let blocks_slot = api.blocks_slot(slot).await;
 92 |     let blocks_by_epoch_and_slot = api.blocks_by_epoch_and_slot(epoch, slot).await; // Not found
 93 |     let blocks_next = api.blocks_next(block, pagination).await;
 94 |     let blocks_previous = api.blocks_previous(block, pagination).await;
 95 |     let blocks_txs = api.blocks_txs(block, pagination).await;
 96 |     let blocks_affected_addresses = api.blocks_affected_addresses("3746845", pagination).await;
 97 | 
 98 |     // Ledger
 99 |     let genesis = api.genesis().await;
100 | 
101 |     // Metadata
102 |     let label = "1990";
103 |     let metadata_txs_labels = api.metadata_txs_labels(pagination).await;
104 |     let metadata_txs_by_label = api.metadata_txs_by_label(label, pagination).await;
105 |     let metadata_txs_by_label_cbor = api.metadata_txs_by_label_cbor(label, pagination).await;
106 | 
107 |     // Network
108 |     let network = api.network().await;
109 | 
110 |     // Scripts
111 |     let script_hash = "e1457a0c47dfb7a2f6b8fbb059bdceab163c05d34f195b87b9f2b30e";
112 |     let scripts = api.scripts(pagination).await;
113 |     let scripts_by_id = api.scripts_by_id(script_hash).await;
114 |     let scripts_redeemers = api.scripts_redeemers(script_hash, pagination).await;
115 | 
116 |     // Transactions
117 |     let transaction_hash = "cb0e7b0cd0f0edbe5c6e260c369f5f0f0069cd41f501243ab67f1052040de28f";
118 |     let transaction_by_hash = api.transaction_by_hash(transaction_hash).await;
119 |     let transactions_utxos = api.transactions_utxos(transaction_hash).await;
120 |     let transactions_stakes = api.transactions_stakes(transaction_hash).await;
121 |     let transactions_delegations = api.transactions_delegations(transaction_hash).await;
122 |     let transactions_withdrawals = api.transactions_withdrawals(transaction_hash).await;
123 |     let transactions_mirs = api.transactions_mirs(transaction_hash).await;
124 |     let transactions_pool_updates = api.transactions_pool_updates(transaction_hash).await;
125 |     let transactions_pool_retires = api.transactions_pool_retires(transaction_hash).await;
126 |     let transactions_metadata = api.transactions_metadata(transaction_hash).await;
127 |     let transactions_metadata_cbor = api.transactions_metadata_cbor(transaction_hash).await;
128 |     let transactions_redeemers = api.transactions_redeemers(transaction_hash).await;
129 | 
130 |     // Nutlink
131 |     let address =
132 |         "addr1qxqs59lphg8g6qndelq8xwqn60ag3aeyfcp33c2kdp46a09re5df3pzwwmyq946axfcejy5n4x0y99wqpgtp2gd0k09qsgy6pz";
133 |     let ticker = "ADAUSD";
134 |     let nutlink_address = api.nutlink_address(address).await;
135 |     let nutlink_address_tickers = api.nutlink_address_tickers(address, pagination).await;
136 |     let nutlink_address_ticker_by_id = api
137 |         .nutlink_address_ticker_by_id(address, ticker, pagination)
138 |         .await;
139 |     let nutlink_ticker_by_id = api.nutlink_ticker_by_id(ticker, pagination).await;
140 | 
141 |     // Utils
142 |     let utils_derive_result = api.derive_address("d507c8f866691bd96e131334c355188b1a1d0b2fa0ab11545075aab332d77d9eb19657ad13ee581b56b0f8d744d66ca356b93d42fe176b3de007d53e9c4c4e7a", "0", "1").await;
143 |     let utils_tx_evaluate_result = api.utils_tx_evaluate(tx_data).await;
144 | 
145 |     println!("root: {root:#?}");
146 |     println!("health: {health:#?}");
147 |     println!("health_clock: {health_clock:#?}");
148 |     println!("metrics: {metrics:#?}");
149 |     println!("metrics_endpoints: {metrics_endpoints:#?}");
150 |     println!("accounts: {accounts:#?}");
151 |     println!("accounts_rewards: {accounts_rewards:#?}");
152 |     println!("accounts_history: {accounts_history:#?}");
153 |     println!("accounts_delegations: {accounts_delegations:#?}");
154 |     println!("accounts_registrations: {accounts_registrations:#?}");
155 |     println!("accounts_withdrawals: {accounts_withdrawals:#?}");
156 |     println!("accounts_mirs: {accounts_mirs:#?}");
157 |     println!("accounts_addresses: {accounts_addresses:#?}");
158 |     println!("accounts_addresses_assets: {accounts_addresses_assets:#?}");
159 |     println!("addresses: {addresses:#?}");
160 |     println!("addresses_total: {addresses_total:#?}");
161 |     println!("addresses_utxos: {addresses_utxos:#?}");
162 |     println!("addresses_transactions: {addresses_transactions:#?}");
163 |     println!("accounts_addresses_total: {accounts_addresses_total:#?}");
164 |     println!("assets: {assets:#?}");
165 |     println!("assets_by_id: {assets_by_id:#?}");
166 |     println!("assets_history: {assets_history:#?}");
167 |     println!("assets_transactions: {assets_transactions:#?}");
168 |     println!("assets_addresses: {assets_addresses:#?}");
169 |     println!("assets_policy_by_id: {assets_policy_by_id:#?}");
170 |     println!("epochs_latest: {epochs_latest:#?}");
171 |     println!("epochs_latest_parameters: {epochs_latest_parameters:#?}");
172 |     println!("epochs_by_number: {epochs_by_number:#?}");
173 |     println!("epochs_next: {epochs_next:#?}");
174 |     println!("epochs_previous: {epochs_previous:#?}");
175 |     println!("epochs_stakes: {epochs_stakes:#?}");
176 |     println!("epochs_stakes_by_pool: {epochs_stakes_by_pool:#?}");
177 |     println!("epochs_blocks: {epochs_blocks:#?}");
178 |     println!("epochs_blocks_by_pool: {epochs_blocks_by_pool:#?}");
179 |     println!("epochs_parameters: {epochs_parameters:#?}");
180 |     println!("pools: {pools:#?}");
181 |     println!("pools_retired: {pools_retired:#?}");
182 |     println!("pools_retiring: {pools_retiring:#?}");
183 |     println!("pools_by_id: {pools_by_id:#?}");
184 |     println!("pools_history: {pools_history:#?}");
185 |     println!("pools_metadata: {pools_metadata:#?}");
186 |     println!("pools_relays: {pools_relays:#?}");
187 |     println!("pools_delegators: {pools_delegators:#?}");
188 |     println!("pools_blocks: {pools_blocks:#?}");
189 |     println!("pools_updates: {pools_updates:#?}");
190 |     println!("blocks_latest: {blocks_latest:#?}");
191 |     println!("blocks_latest_txs: {blocks_latest_txs:#?}");
192 |     println!("blocks_by_id: {blocks_by_id:#?}");
193 |     println!("blocks_slot: {blocks_slot:#?}");
194 |     println!("blocks_by_epoch_and_slot: {blocks_by_epoch_and_slot:#?}");
195 |     println!("blocks_next: {blocks_next:#?}");
196 |     println!("blocks_previous: {blocks_previous:#?}");
197 |     println!("blocks_txs: {blocks_txs:#?}");
198 |     println!("blocks_affected_addresses: {blocks_affected_addresses:#?}");
199 |     println!("genesis: {genesis:#?}");
200 |     println!("metadata_txs_labels: {metadata_txs_labels:#?}");
201 |     println!("metadata_txs_by_label: {metadata_txs_by_label:#?}");
202 |     println!("metadata_txs_by_label_cbor: {metadata_txs_by_label_cbor:#?}");
203 |     println!("network: {network:#?}");
204 |     println!("scripts: {scripts:#?}");
205 |     println!("scripts_by_id: {scripts_by_id:#?}");
206 |     println!("scripts_redeemers: {scripts_redeemers:#?}");
207 |     println!("transaction_by_hash: {transaction_by_hash:#?}");
208 |     println!("transactions_utxos: {transactions_utxos:#?}");
209 |     println!("transactions_stakes: {transactions_stakes:#?}");
210 |     println!("transactions_delegations: {transactions_delegations:#?}");
211 |     println!("transactions_withdrawals: {transactions_withdrawals:#?}");
212 |     println!("transactions_mirs: {transactions_mirs:#?}");
213 |     println!("transactions_pool_updates: {transactions_pool_updates:#?}");
214 |     println!("transactions_pool_retires: {transactions_pool_retires:#?}");
215 |     println!("transactions_metadata: {transactions_metadata:#?}");
216 |     println!("transactions_metadata_cbor: {transactions_metadata_cbor:#?}");
217 |     println!("transactions_redeemers: {transactions_redeemers:#?}");
218 |     println!("nutlink_address: {nutlink_address:#?}");
219 |     println!("nutlink_address_tickers: {nutlink_address_tickers:#?}");
220 |     println!("nutlink_address_ticker_by_id: {nutlink_address_ticker_by_id:#?}");
221 |     println!("nutlink_ticker_by_id: {nutlink_ticker_by_id:#?}");
222 |     println!("derive_result: {utils_derive_result:#?}");
223 |     println!("tx_evaluate_result: {utils_tx_evaluate_result:#?}");
224 | 
225 |     Ok(())
226 | }
227 | 


--------------------------------------------------------------------------------