1use cosmwasm_std::{QuerierWrapper, QueryRequest, StdResult};
2
3use crate::query::CyberQuery;
4use crate::query_res::{BandwidthLoadResponse, BandwidthPriceResponse, TotalBandwidthResponse, GraphStatsResponse, ThoughtsFeesResponse, NeuronBandwidthResponse, ParticleRankResponse, RouteResponse, RoutedEnergyResponse, RoutesResponse, ThoughtResponse, ThoughtStatsResponse, PoolParamsResponse, PoolLiquidityResponse, PoolSupplyResponse, PoolPriceResponse, PoolAddressResponse};
5use crate::tokenfactory::query::{AdminResponse, DenomsByCreatorResponse, FullDenomResponse, MetadataResponse, ParamsResponse};
6
7pub struct CyberQuerier<'a> {
8 querier: &'a QuerierWrapper<'a, CyberQuery>,
9}
10
11impl<'a> CyberQuerier<'a> {
12 pub fn new(querier: &'a QuerierWrapper<'a, CyberQuery>) -> Self {
13 CyberQuerier { querier }
14 }
15
16 pub fn query_particle_rank<T: Into<String>>(
17 &self,
18 particle: T,
19 ) -> StdResult<ParticleRankResponse> {
20 let request = QueryRequest::Custom(CyberQuery::particle_rank ( particle.into() ));
21 let res: ParticleRankResponse = self.querier.query(&request.into())?;
22
23 Ok(res)
24 }
25
26 pub fn query_graph_stats(&self) -> StdResult<GraphStatsResponse> {
27 let request = QueryRequest::Custom(CyberQuery::graph_stats());
28 let res: GraphStatsResponse = self.querier.query(&request.into())?;
29
30 Ok(res)
31 }
32
33 pub fn query_thought<T: Into<String>>(
34 &self,
35 program: T,
36 name: T,
37 ) -> StdResult<ThoughtResponse> {
38 let request = QueryRequest::Custom(CyberQuery::thought ( program.into(), name.into() ));
39 let res: ThoughtResponse = self.querier.query(&request.into())?;
40 Ok(res)
41 }
42
43 pub fn query_thought_stats<T: Into<String>>(
44 &self,
45 program: T,
46 name: T,
47 ) -> StdResult<ThoughtStatsResponse> {
48 let request = QueryRequest::Custom(CyberQuery::thought_stats ( program.into(), name.into() ));
49 let res: ThoughtStatsResponse = self.querier.query(&request.into())?;
50
51 Ok(res)
52 }
53
54 pub fn query_thoughts_fees(&self) -> StdResult<ThoughtsFeesResponse> {
55 let request = QueryRequest::Custom(CyberQuery::thoughts_fees());
56 let res: ThoughtsFeesResponse = self.querier.query(&request.into())?;
57
58 Ok(res)
59 }
60
61 pub fn query_source_routes<T: Into<String>>(&self, source: T) -> StdResult<RoutesResponse> {
62 let request = QueryRequest::Custom(CyberQuery::source_routes ( source.into() ));
63 let res: RoutesResponse = self.querier.query(&request.into())?;
64
65 Ok(res)
66 }
67
68 pub fn query_source_routed_energy<T: Into<String>>(
69 &self,
70 source: T,
71 ) -> StdResult<RoutedEnergyResponse> {
72 let request = QueryRequest::Custom(CyberQuery::source_routed_energy ( source.into() ));
73 let res: RoutedEnergyResponse = self.querier.query(&request.into())?;
74
75 Ok(res)
76 }
77
78 pub fn query_destination_routed_energy<T: Into<String>>(
79 &self,
80 destination: T,
81 ) -> StdResult<RoutedEnergyResponse> {
82 let request = QueryRequest::Custom(CyberQuery::destination_routed_energy ( destination.into() ));
83 let res: RoutedEnergyResponse = self.querier.query(&request.into())?;
84
85 Ok(res)
86 }
87
88 pub fn query_route<T: Into<String>>(
89 &self,
90 source: T,
91 destination: T,
92 ) -> StdResult<RouteResponse> {
93 let request = QueryRequest::Custom(CyberQuery::route ( source.into(), destination.into() ));
94 let res: RouteResponse = self.querier.query(&request.into())?;
95
96 Ok(res)
97 }
98
99 pub fn query_bandwidth_price(&self) -> StdResult<BandwidthPriceResponse> {
100 let request = QueryRequest::Custom(CyberQuery::bandwidth_price());
101 let res: BandwidthPriceResponse = self.querier.query(&request.into())?;
102
103 Ok(res)
104 }
105
106 pub fn query_bandwidth_load(&self) -> StdResult<BandwidthLoadResponse> {
107 let request = QueryRequest::Custom(CyberQuery::bandwidth_load());
108 let res: BandwidthLoadResponse = self.querier.query(&request.into())?;
109
110 Ok(res)
111 }
112
113 pub fn query_total_bandwidth(&self) -> StdResult<TotalBandwidthResponse> {
114 let request = QueryRequest::Custom(CyberQuery::bandwidth_total());
115 let res: TotalBandwidthResponse = self.querier.query(&request.into())?;
116
117 Ok(res)
118 }
119
120 pub fn query_neuron_bandwidth<T: Into<String>>(
121 &self,
122 address: T,
123 ) -> StdResult<NeuronBandwidthResponse> {
124 let request = QueryRequest::Custom(CyberQuery::neuron_bandwidth ( address.into() ));
125 let res: NeuronBandwidthResponse = self.querier.query(&request.into())?;
126
127 Ok(res)
128 }
129
130 pub fn query_pool_params(
131 &self,
132 pool_id: u64,
133 ) -> StdResult<PoolParamsResponse> {
134 let request = QueryRequest::Custom(CyberQuery::pool_params ( pool_id.into() ));
135 let res: PoolParamsResponse = self.querier.query(&request.into())?;
136
137 Ok(res)
138 }
139
140 pub fn query_pool_liquidity(
141 &self,
142 pool_id: u64,
143 ) -> StdResult<PoolLiquidityResponse> {
144 let request = QueryRequest::Custom(CyberQuery::pool_liquidity ( pool_id.into() ));
145 let res: PoolLiquidityResponse = self.querier.query(&request.into())?;
146
147 Ok(res)
148 }
149
150 pub fn query_pool_supply(
151 &self,
152 pool_id: u64,
153 ) -> StdResult<PoolSupplyResponse> {
154 let request = QueryRequest::Custom(CyberQuery::pool_supply ( pool_id.into() ));
155 let res: PoolSupplyResponse = self.querier.query(&request.into())?;
156
157 Ok(res)
158 }
159
160 pub fn query_pool_price(
161 &self,
162 pool_id: u64,
163 ) -> StdResult<PoolPriceResponse> {
164 let request = QueryRequest::Custom(CyberQuery::pool_price ( pool_id.into() ));
165 let res: PoolPriceResponse = self.querier.query(&request.into())?;
166
167 Ok(res)
168 }
169
170 pub fn query_pool_address(
171 &self,
172 pool_id: u64,
173 ) -> StdResult<PoolAddressResponse> {
174 let request = QueryRequest::Custom(CyberQuery::pool_address ( pool_id.into() ));
175 let res: PoolAddressResponse = self.querier.query(&request.into())?;
176
177
178 Ok(res)
179 }
180
181 pub fn query_full_denom(
182 &self,
183 creator_addr: String,
184 subdenom: String,
185 ) -> StdResult<FullDenomResponse> {
186 let request = QueryRequest::Custom(CyberQuery::full_denom ( creator_addr.into(), subdenom.into() ));
187 let res = self.querier.query(&request.into())?;
188
189 Ok(res)
190 }
191
192 pub fn query_denom_metadata(
193 &self,
194 denom: String,
195 ) -> StdResult<MetadataResponse> {
196 let request = QueryRequest::Custom(CyberQuery::denom_metadata ( denom.into() ));
197 let res = self.querier.query(&request.into())?;
198
199 Ok(res)
200 }
201
202 pub fn query_denom_admin(
203 &self,
204 denom: String,
205 ) -> StdResult<AdminResponse> {
206 let request = QueryRequest::Custom(CyberQuery::denom_admin ( denom.into() ));
207 let res = self.querier.query(&request.into())?;
208
209 Ok(res)
210 }
211
212 pub fn query_denoms_by_creator(
213 &self,
214 denom: String,
215 ) -> StdResult<DenomsByCreatorResponse> {
216 let request = QueryRequest::Custom(CyberQuery::denoms_by_creator ( denom.into() ));
217 let res = self.querier.query(&request.into())?;
218
219 Ok(res)
220 }
221
222 pub fn query_denom_creation_fee(
223 &self,
224 ) -> StdResult<ParamsResponse> {
225 let request = QueryRequest::Custom(CyberQuery::denom_creation_fee());
226 let res = self.querier.query(&request.into())?;
227
228 Ok(res)
229 }
230}