Skip to main content

provable_sdk/
config.rs

1use base64::engine::general_purpose::STANDARD as BASE64_STANDARD;
2use base64::Engine;
3use once_cell::sync::Lazy;
4use std::sync::RwLock;
5
6pub const KAYROS_HOST: &str = "https://kayros.provable.dev";
7pub const PROVE_SINGLE_HASH_ROUTE: &str = "/api/lightnet/grpc/single-hash";
8pub const GET_RECORD_BY_HASH_ROUTE: &str = "/api/lightnet/database/record-by-hash";
9pub const GET_RECORD_BY_DATA_ITEM_ROUTE: &str = "/api/lightnet/database/record";
10pub const COMPUTE_HASH_FROM_HEX_ROUTE: &str = "/api/lightnet/compute-hash-from-hex";
11pub const GET_MERKLE_PROOF_ROUTE: &str = "/api/lightnet/merkle-proof";
12pub const VERIFY_HASH_EXISTENCE_ROUTE: &str = "/api/lightnet/merkle/verify-hash-existence";
13pub const VERIFY_HASH_BATCH_ROUTE: &str = "/api/lightnet/merkle/verify-hash-batch";
14
15pub const DATA_TYPE: &str = "provable_sdk";
16pub const DEFAULT_USER_KEY: &str =
17    "0x0000000000000000000000000000000000000000000000000000000000000001";
18pub const DEFAULT_API_KEY: &str = DEFAULT_USER_KEY;
19
20static KAYROS_HOST_OVERRIDE: Lazy<RwLock<String>> =
21    Lazy::new(|| RwLock::new(KAYROS_HOST.to_string()));
22static API_KEY_OVERRIDE: Lazy<RwLock<String>> =
23    Lazy::new(|| RwLock::new(DEFAULT_API_KEY.to_string()));
24
25pub fn set_kayros_host(host: impl Into<String>) {
26    *KAYROS_HOST_OVERRIDE.write().expect("kayros host lock") = host.into();
27}
28
29pub fn get_kayros_host() -> String {
30    KAYROS_HOST_OVERRIDE
31        .read()
32        .expect("kayros host lock")
33        .clone()
34}
35
36pub fn get_kayros_url(route: &str) -> String {
37    format!("{}{}", get_kayros_host(), route)
38}
39
40pub fn set_user_key(key: impl Into<String>) {
41    *API_KEY_OVERRIDE.write().expect("api key lock") = key.into();
42}
43
44pub fn get_user_key() -> String {
45    API_KEY_OVERRIDE.read().expect("api key lock").clone()
46}
47
48pub fn set_api_key(key: impl Into<String>) {
49    set_user_key(key);
50}
51
52pub fn get_api_key() -> String {
53    get_user_key()
54}
55
56pub fn resolve_api_key(override_key: Option<&str>) -> String {
57    override_key
58        .filter(|value| !value.is_empty())
59        .map(ToOwned::to_owned)
60        .unwrap_or_else(get_api_key)
61}
62
63pub fn format_data_type_for_query(data_type: &str) -> String {
64    data_type.to_string()
65}
66
67pub fn format_hash_for_query(hash: &str) -> String {
68    let trimmed = hash.trim();
69    if trimmed.len() == 64 && trimmed.chars().all(|ch| ch.is_ascii_hexdigit()) {
70        return hex::decode(trimmed)
71            .ok()
72            .map(|bytes| BASE64_STANDARD.encode(bytes))
73            .unwrap_or_else(|| trimmed.to_string());
74    }
75    trimmed.to_string()
76}
77
78pub fn get_record_url(hash: &str, data_type: Option<&str>) -> String {
79    let hash_value = format_hash_for_query(hash);
80    let data_type_value = format_data_type_for_query(data_type.unwrap_or(DATA_TYPE));
81    let formatted_hash = urlencoding::encode(&hash_value);
82    let formatted_data_type = urlencoding::encode(&data_type_value);
83    format!(
84        "{}{}?hash={}&data_type={}",
85        get_kayros_host(),
86        GET_RECORD_BY_HASH_ROUTE,
87        formatted_hash,
88        formatted_data_type
89    )
90}