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}