Skip to main content

provable_sdk/
lightnet.rs

1use crate::config::{
2    get_kayros_url, COMPUTE_HASH_FROM_HEX_ROUTE, GET_MERKLE_PROOF_ROUTE,
3    GET_RECORD_BY_DATA_ITEM_ROUTE, VERIFY_HASH_BATCH_ROUTE, VERIFY_HASH_EXISTENCE_ROUTE,
4};
5use crate::error::Result;
6use crate::http::{get_json, post_json};
7use crate::types::{
8    ApiResponse, ColumnInfo, ComputeHashRequest, ComputeHashResponse, DatabaseQuery,
9    DatabaseRecord, DatabaseStats, GetRecordByDataItemResponse, HashBatchRequest,
10    HashBatchResponse, HashExistenceRequest, HashExistenceResponse, HashRecord, HashVerifyRequest,
11    HashVerifyResult, MerkleProofResponse, SingleHashRequest, SingleHashResponse,
12    TableBrowseRequest,
13};
14
15pub fn query_hashes(query: &DatabaseQuery) -> Result<ApiResponse<Vec<HashRecord>>> {
16    post_json(&get_kayros_url("/api/database/query"), query, None)
17}
18
19pub fn get_database_stats() -> Result<ApiResponse<DatabaseStats>> {
20    get_json(&get_kayros_url("/api/database/stats"), None)
21}
22
23pub fn get_latest_hashes(limit: usize) -> Result<ApiResponse<Vec<HashRecord>>> {
24    get_json(
25        &format!("{}?limit={}", get_kayros_url("/api/database/latest"), limit),
26        None,
27    )
28}
29
30pub fn get_tables() -> Result<ApiResponse<Vec<String>>> {
31    get_json(&get_kayros_url("/api/database/tables"), None)
32}
33
34pub fn get_table_schema(table_name: &str) -> Result<ApiResponse<Vec<ColumnInfo>>> {
35    get_json(
36        &format!(
37            "{}?table={}",
38            get_kayros_url("/api/database/schema"),
39            urlencoding::encode(table_name)
40        ),
41        None,
42    )
43}
44
45pub fn browse_table(request: &TableBrowseRequest) -> Result<ApiResponse<Vec<serde_json::Value>>> {
46    post_json(&get_kayros_url("/api/database/browse"), request, None)
47}
48
49pub fn get_record(uuid: &str) -> Result<ApiResponse<DatabaseRecord>> {
50    get_json(
51        &format!(
52            "{}?uuid={}",
53            get_kayros_url("/api/database/record"),
54            urlencoding::encode(uuid)
55        ),
56        None,
57    )
58}
59
60pub fn get_record_with_prev_hash(uuid: &str) -> Result<ApiResponse<DatabaseRecord>> {
61    get_json(
62        &format!(
63            "{}?uuid={}",
64            get_kayros_url("/api/database/record-with-prev"),
65            urlencoding::encode(uuid)
66        ),
67        None,
68    )
69}
70
71pub fn get_record_by_data_item(
72    data_type: &str,
73    data_item: &str,
74    api_key: Option<&str>,
75    limit: Option<usize>,
76) -> Result<GetRecordByDataItemResponse> {
77    let mut url = format!(
78        "{}?data_type={}&data_item={}",
79        get_kayros_url(GET_RECORD_BY_DATA_ITEM_ROUTE),
80        urlencoding::encode(data_type),
81        urlencoding::encode(data_item)
82    );
83    if let Some(limit_value) = limit {
84        url.push_str("&limit=");
85        url.push_str(&limit_value.to_string());
86    }
87    get_json(&url, api_key)
88}
89
90pub fn verify_hash(request: &HashVerifyRequest) -> Result<ApiResponse<HashVerifyResult>> {
91    post_json(&get_kayros_url("/api/verify-hash"), request, None)
92}
93
94pub fn compute_hash_from_hex_lightnet(
95    request: &ComputeHashRequest,
96    api_key: Option<&str>,
97) -> Result<ComputeHashResponse> {
98    post_json(
99        &get_kayros_url(COMPUTE_HASH_FROM_HEX_ROUTE),
100        request,
101        api_key,
102    )
103}
104
105pub fn send_single_grpc_request(
106    request: &SingleHashRequest,
107) -> Result<ApiResponse<SingleHashResponse>> {
108    post_json(
109        &get_kayros_url(crate::config::PROVE_SINGLE_HASH_ROUTE),
110        request,
111        None,
112    )
113}
114
115pub fn get_merkle_proof(
116    data_type: &str,
117    hash: Option<&str>,
118    position: Option<i64>,
119    api_key: Option<&str>,
120) -> Result<MerkleProofResponse> {
121    let mut url = format!(
122        "{}?data_type={}",
123        get_kayros_url(GET_MERKLE_PROOF_ROUTE),
124        urlencoding::encode(data_type)
125    );
126    if let Some(hash_value) = hash {
127        url.push_str("&hash=");
128        url.push_str(&urlencoding::encode(hash_value));
129    }
130    if let Some(position_value) = position {
131        url.push_str("&position=");
132        url.push_str(&position_value.to_string());
133    }
134    get_json(&url, api_key)
135}
136
137pub fn verify_hash_existence(
138    request: &HashExistenceRequest,
139    api_key: Option<&str>,
140) -> Result<HashExistenceResponse> {
141    post_json(
142        &get_kayros_url(VERIFY_HASH_EXISTENCE_ROUTE),
143        request,
144        api_key,
145    )
146}
147
148pub fn verify_hash_batch(
149    request: &HashBatchRequest,
150    api_key: Option<&str>,
151) -> Result<HashBatchResponse> {
152    post_json(&get_kayros_url(VERIFY_HASH_BATCH_ROUTE), request, api_key)
153}