inx/opt/rustwide/target/x86_64-unknown-linux-gnu/debug/build/inx-438cae180b119e48/out/
inx.rs

1#[allow(clippy::derive_partial_eq_without_eq)]
2#[derive(Clone, PartialEq, ::prost::Message)]
3pub struct NoParams {}
4/// Node
5#[allow(clippy::derive_partial_eq_without_eq)]
6#[derive(Clone, PartialEq, ::prost::Message)]
7pub struct NodeConfiguration {
8    #[prost(uint32, tag = "1")]
9    pub milestone_public_key_count: u32,
10    #[prost(message, repeated, tag = "2")]
11    pub milestone_key_ranges: ::prost::alloc::vec::Vec<MilestoneKeyRange>,
12    #[prost(message, optional, tag = "3")]
13    pub base_token: ::core::option::Option<BaseToken>,
14    #[prost(uint32, repeated, tag = "4")]
15    pub supported_protocol_versions: ::prost::alloc::vec::Vec<u32>,
16}
17#[allow(clippy::derive_partial_eq_without_eq)]
18#[derive(Clone, PartialEq, ::prost::Message)]
19pub struct BaseToken {
20    #[prost(string, tag = "1")]
21    pub name: ::prost::alloc::string::String,
22    #[prost(string, tag = "2")]
23    pub ticker_symbol: ::prost::alloc::string::String,
24    #[prost(string, tag = "3")]
25    pub unit: ::prost::alloc::string::String,
26    #[prost(string, tag = "4")]
27    pub subunit: ::prost::alloc::string::String,
28    #[prost(uint32, tag = "5")]
29    pub decimals: u32,
30    #[prost(bool, tag = "6")]
31    pub use_metric_prefix: bool,
32}
33#[allow(clippy::derive_partial_eq_without_eq)]
34#[derive(Clone, PartialEq, ::prost::Message)]
35pub struct MilestoneKeyRange {
36    #[prost(bytes = "vec", tag = "1")]
37    pub public_key: ::prost::alloc::vec::Vec<u8>,
38    #[prost(uint32, tag = "2")]
39    pub start_index: u32,
40    #[prost(uint32, tag = "3")]
41    pub end_index: u32,
42}
43#[allow(clippy::derive_partial_eq_without_eq)]
44#[derive(Clone, PartialEq, ::prost::Message)]
45pub struct NodeStatus {
46    #[prost(bool, tag = "1")]
47    pub is_healthy: bool,
48    #[prost(bool, tag = "2")]
49    pub is_synced: bool,
50    #[prost(bool, tag = "3")]
51    pub is_almost_synced: bool,
52    #[prost(message, optional, tag = "4")]
53    pub latest_milestone: ::core::option::Option<Milestone>,
54    #[prost(message, optional, tag = "5")]
55    pub confirmed_milestone: ::core::option::Option<Milestone>,
56    #[prost(message, optional, tag = "6")]
57    pub current_protocol_parameters: ::core::option::Option<RawProtocolParameters>,
58    #[prost(uint32, tag = "7")]
59    pub tangle_pruning_index: u32,
60    #[prost(uint32, tag = "8")]
61    pub milestones_pruning_index: u32,
62    #[prost(uint32, tag = "9")]
63    pub ledger_pruning_index: u32,
64    #[prost(uint32, tag = "10")]
65    pub ledger_index: u32,
66}
67#[allow(clippy::derive_partial_eq_without_eq)]
68#[derive(Clone, PartialEq, ::prost::Message)]
69pub struct NodeStatusRequest {
70    #[prost(uint32, tag = "1")]
71    pub cooldown_in_milliseconds: u32,
72}
73#[allow(clippy::derive_partial_eq_without_eq)]
74#[derive(Clone, PartialEq, ::prost::Message)]
75pub struct RawProtocolParameters {
76    #[prost(uint32, tag = "1")]
77    pub protocol_version: u32,
78    #[prost(bytes = "vec", tag = "2")]
79    pub params: ::prost::alloc::vec::Vec<u8>,
80}
81/// Milestones
82#[allow(clippy::derive_partial_eq_without_eq)]
83#[derive(Clone, PartialEq, ::prost::Message)]
84pub struct RawMilestone {
85    #[prost(bytes = "vec", tag = "1")]
86    pub data: ::prost::alloc::vec::Vec<u8>,
87}
88#[allow(clippy::derive_partial_eq_without_eq)]
89#[derive(Clone, PartialEq, ::prost::Message)]
90pub struct MilestoneId {
91    #[prost(bytes = "vec", tag = "1")]
92    pub id: ::prost::alloc::vec::Vec<u8>,
93}
94#[allow(clippy::derive_partial_eq_without_eq)]
95#[derive(Clone, PartialEq, ::prost::Message)]
96pub struct MilestoneRequest {
97    #[prost(uint32, tag = "1")]
98    pub milestone_index: u32,
99    #[prost(message, optional, tag = "2")]
100    pub milestone_id: ::core::option::Option<MilestoneId>,
101}
102#[allow(clippy::derive_partial_eq_without_eq)]
103#[derive(Clone, PartialEq, ::prost::Message)]
104pub struct MilestoneRangeRequest {
105    /// start_milestone_index is the initial milestone to get. Use 0 to start from the current node status.
106    #[prost(uint32, tag = "1")]
107    pub start_milestone_index: u32,
108    /// end_milestone_index is the last milestone to get (inclusive). Use 0 to keep getting new confirmed milestones.
109    #[prost(uint32, tag = "2")]
110    pub end_milestone_index: u32,
111}
112#[allow(clippy::derive_partial_eq_without_eq)]
113#[derive(Clone, PartialEq, ::prost::Message)]
114pub struct MilestoneInfo {
115    /// Optional. This field can be missing for example if there are no milestones yet in a network.
116    #[prost(message, optional, tag = "1")]
117    pub milestone_id: ::core::option::Option<MilestoneId>,
118    #[prost(uint32, tag = "2")]
119    pub milestone_index: u32,
120    /// Optional. This field can be missing for example if there are no milestones yet in a network.
121    #[prost(uint32, tag = "3")]
122    pub milestone_timestamp: u32,
123}
124#[allow(clippy::derive_partial_eq_without_eq)]
125#[derive(Clone, PartialEq, ::prost::Message)]
126pub struct Milestone {
127    #[prost(message, optional, tag = "1")]
128    pub milestone_info: ::core::option::Option<MilestoneInfo>,
129    /// Optional. This field can be missing for example if there are no milestones yet in a network.
130    #[prost(message, optional, tag = "2")]
131    pub milestone: ::core::option::Option<RawMilestone>,
132}
133#[allow(clippy::derive_partial_eq_without_eq)]
134#[derive(Clone, PartialEq, ::prost::Message)]
135pub struct MilestoneAndProtocolParameters {
136    #[prost(message, optional, tag = "1")]
137    pub milestone: ::core::option::Option<Milestone>,
138    #[prost(message, optional, tag = "2")]
139    pub current_protocol_parameters: ::core::option::Option<RawProtocolParameters>,
140}
141#[allow(clippy::derive_partial_eq_without_eq)]
142#[derive(Clone, PartialEq, ::prost::Message)]
143pub struct WhiteFlagRequest {
144    #[prost(uint32, tag = "1")]
145    pub milestone_index: u32,
146    #[prost(uint32, tag = "2")]
147    pub milestone_timestamp: u32,
148    #[prost(message, repeated, tag = "3")]
149    pub parents: ::prost::alloc::vec::Vec<BlockId>,
150    #[prost(message, optional, tag = "4")]
151    pub previous_milestone_id: ::core::option::Option<MilestoneId>,
152}
153#[allow(clippy::derive_partial_eq_without_eq)]
154#[derive(Clone, PartialEq, ::prost::Message)]
155pub struct WhiteFlagResponse {
156    #[prost(bytes = "vec", tag = "1")]
157    pub milestone_inclusion_merkle_root: ::prost::alloc::vec::Vec<u8>,
158    #[prost(bytes = "vec", tag = "2")]
159    pub milestone_applied_merkle_root: ::prost::alloc::vec::Vec<u8>,
160}
161/// Blocks
162#[allow(clippy::derive_partial_eq_without_eq)]
163#[derive(Clone, PartialEq, ::prost::Message)]
164pub struct RawBlock {
165    #[prost(bytes = "vec", tag = "1")]
166    pub data: ::prost::alloc::vec::Vec<u8>,
167}
168#[allow(clippy::derive_partial_eq_without_eq)]
169#[derive(Clone, PartialEq, ::prost::Message)]
170pub struct BlockId {
171    #[prost(bytes = "vec", tag = "1")]
172    pub id: ::prost::alloc::vec::Vec<u8>,
173}
174#[allow(clippy::derive_partial_eq_without_eq)]
175#[derive(Clone, PartialEq, ::prost::Message)]
176pub struct Block {
177    #[prost(message, optional, tag = "1")]
178    pub block_id: ::core::option::Option<BlockId>,
179    #[prost(message, optional, tag = "2")]
180    pub block: ::core::option::Option<RawBlock>,
181}
182#[allow(clippy::derive_partial_eq_without_eq)]
183#[derive(Clone, PartialEq, ::prost::Message)]
184pub struct BlockWithMetadata {
185    #[prost(message, optional, tag = "1")]
186    pub metadata: ::core::option::Option<BlockMetadata>,
187    #[prost(message, optional, tag = "2")]
188    pub block: ::core::option::Option<RawBlock>,
189}
190#[allow(clippy::derive_partial_eq_without_eq)]
191#[derive(Clone, PartialEq, ::prost::Message)]
192pub struct BlockMetadata {
193    #[prost(message, optional, tag = "1")]
194    pub block_id: ::core::option::Option<BlockId>,
195    #[prost(message, repeated, tag = "2")]
196    pub parents: ::prost::alloc::vec::Vec<BlockId>,
197    #[prost(bool, tag = "3")]
198    pub solid: bool,
199    #[prost(bool, tag = "4")]
200    pub should_promote: bool,
201    #[prost(bool, tag = "5")]
202    pub should_reattach: bool,
203    #[prost(uint32, tag = "6")]
204    pub referenced_by_milestone_index: u32,
205    #[prost(uint32, tag = "7")]
206    pub milestone_index: u32,
207    #[prost(enumeration = "block_metadata::LedgerInclusionState", tag = "8")]
208    pub ledger_inclusion_state: i32,
209    #[prost(enumeration = "block_metadata::ConflictReason", tag = "9")]
210    pub conflict_reason: i32,
211    #[prost(uint32, tag = "10")]
212    pub white_flag_index: u32,
213}
214/// Nested message and enum types in `BlockMetadata`.
215pub mod block_metadata {
216    #[derive(
217        Clone,
218        Copy,
219        Debug,
220        PartialEq,
221        Eq,
222        Hash,
223        PartialOrd,
224        Ord,
225        ::prost::Enumeration
226    )]
227    #[repr(i32)]
228    pub enum LedgerInclusionState {
229        NoTransaction = 0,
230        Included = 1,
231        Conflicting = 2,
232    }
233    impl LedgerInclusionState {
234        /// String value of the enum field names used in the ProtoBuf definition.
235        ///
236        /// The values are not transformed in any way and thus are considered stable
237        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
238        pub fn as_str_name(&self) -> &'static str {
239            match self {
240                LedgerInclusionState::NoTransaction => {
241                    "LEDGER_INCLUSION_STATE_NO_TRANSACTION"
242                }
243                LedgerInclusionState::Included => "LEDGER_INCLUSION_STATE_INCLUDED",
244                LedgerInclusionState::Conflicting => "LEDGER_INCLUSION_STATE_CONFLICTING",
245            }
246        }
247        /// Creates an enum from field names used in the ProtoBuf definition.
248        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
249            match value {
250                "LEDGER_INCLUSION_STATE_NO_TRANSACTION" => Some(Self::NoTransaction),
251                "LEDGER_INCLUSION_STATE_INCLUDED" => Some(Self::Included),
252                "LEDGER_INCLUSION_STATE_CONFLICTING" => Some(Self::Conflicting),
253                _ => None,
254            }
255        }
256    }
257    #[derive(
258        Clone,
259        Copy,
260        Debug,
261        PartialEq,
262        Eq,
263        Hash,
264        PartialOrd,
265        Ord,
266        ::prost::Enumeration
267    )]
268    #[repr(i32)]
269    pub enum ConflictReason {
270        None = 0,
271        InputAlreadySpent = 1,
272        InputAlreadySpentInThisMilestone = 2,
273        InputNotFound = 3,
274        InputOutputSumMismatch = 4,
275        InvalidSignature = 5,
276        TimelockNotExpired = 6,
277        InvalidNativeTokens = 7,
278        ReturnAmountNotFulfilled = 8,
279        InvalidInputUnlock = 9,
280        InvalidInputsCommitment = 10,
281        InvalidSender = 11,
282        InvalidChainStateTransition = 12,
283        SemanticValidationFailed = 255,
284    }
285    impl ConflictReason {
286        /// String value of the enum field names used in the ProtoBuf definition.
287        ///
288        /// The values are not transformed in any way and thus are considered stable
289        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
290        pub fn as_str_name(&self) -> &'static str {
291            match self {
292                ConflictReason::None => "CONFLICT_REASON_NONE",
293                ConflictReason::InputAlreadySpent => {
294                    "CONFLICT_REASON_INPUT_ALREADY_SPENT"
295                }
296                ConflictReason::InputAlreadySpentInThisMilestone => {
297                    "CONFLICT_REASON_INPUT_ALREADY_SPENT_IN_THIS_MILESTONE"
298                }
299                ConflictReason::InputNotFound => "CONFLICT_REASON_INPUT_NOT_FOUND",
300                ConflictReason::InputOutputSumMismatch => {
301                    "CONFLICT_REASON_INPUT_OUTPUT_SUM_MISMATCH"
302                }
303                ConflictReason::InvalidSignature => "CONFLICT_REASON_INVALID_SIGNATURE",
304                ConflictReason::TimelockNotExpired => {
305                    "CONFLICT_REASON_TIMELOCK_NOT_EXPIRED"
306                }
307                ConflictReason::InvalidNativeTokens => {
308                    "CONFLICT_REASON_INVALID_NATIVE_TOKENS"
309                }
310                ConflictReason::ReturnAmountNotFulfilled => {
311                    "CONFLICT_REASON_RETURN_AMOUNT_NOT_FULFILLED"
312                }
313                ConflictReason::InvalidInputUnlock => {
314                    "CONFLICT_REASON_INVALID_INPUT_UNLOCK"
315                }
316                ConflictReason::InvalidInputsCommitment => {
317                    "CONFLICT_REASON_INVALID_INPUTS_COMMITMENT"
318                }
319                ConflictReason::InvalidSender => "CONFLICT_REASON_INVALID_SENDER",
320                ConflictReason::InvalidChainStateTransition => {
321                    "CONFLICT_REASON_INVALID_CHAIN_STATE_TRANSITION"
322                }
323                ConflictReason::SemanticValidationFailed => {
324                    "CONFLICT_REASON_SEMANTIC_VALIDATION_FAILED"
325                }
326            }
327        }
328        /// Creates an enum from field names used in the ProtoBuf definition.
329        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
330            match value {
331                "CONFLICT_REASON_NONE" => Some(Self::None),
332                "CONFLICT_REASON_INPUT_ALREADY_SPENT" => Some(Self::InputAlreadySpent),
333                "CONFLICT_REASON_INPUT_ALREADY_SPENT_IN_THIS_MILESTONE" => {
334                    Some(Self::InputAlreadySpentInThisMilestone)
335                }
336                "CONFLICT_REASON_INPUT_NOT_FOUND" => Some(Self::InputNotFound),
337                "CONFLICT_REASON_INPUT_OUTPUT_SUM_MISMATCH" => {
338                    Some(Self::InputOutputSumMismatch)
339                }
340                "CONFLICT_REASON_INVALID_SIGNATURE" => Some(Self::InvalidSignature),
341                "CONFLICT_REASON_TIMELOCK_NOT_EXPIRED" => Some(Self::TimelockNotExpired),
342                "CONFLICT_REASON_INVALID_NATIVE_TOKENS" => {
343                    Some(Self::InvalidNativeTokens)
344                }
345                "CONFLICT_REASON_RETURN_AMOUNT_NOT_FULFILLED" => {
346                    Some(Self::ReturnAmountNotFulfilled)
347                }
348                "CONFLICT_REASON_INVALID_INPUT_UNLOCK" => Some(Self::InvalidInputUnlock),
349                "CONFLICT_REASON_INVALID_INPUTS_COMMITMENT" => {
350                    Some(Self::InvalidInputsCommitment)
351                }
352                "CONFLICT_REASON_INVALID_SENDER" => Some(Self::InvalidSender),
353                "CONFLICT_REASON_INVALID_CHAIN_STATE_TRANSITION" => {
354                    Some(Self::InvalidChainStateTransition)
355                }
356                "CONFLICT_REASON_SEMANTIC_VALIDATION_FAILED" => {
357                    Some(Self::SemanticValidationFailed)
358                }
359                _ => None,
360            }
361        }
362    }
363}
364/// Tips
365#[allow(clippy::derive_partial_eq_without_eq)]
366#[derive(Clone, PartialEq, ::prost::Message)]
367pub struct TipsRequest {
368    #[prost(uint32, tag = "1")]
369    pub count: u32,
370    #[prost(bool, tag = "2")]
371    pub allow_semi_lazy: bool,
372}
373#[allow(clippy::derive_partial_eq_without_eq)]
374#[derive(Clone, PartialEq, ::prost::Message)]
375pub struct TipsResponse {
376    #[prost(message, repeated, tag = "1")]
377    pub tips: ::prost::alloc::vec::Vec<BlockId>,
378}
379#[allow(clippy::derive_partial_eq_without_eq)]
380#[derive(Clone, PartialEq, ::prost::Message)]
381pub struct TipsMetricRequest {
382    #[prost(uint32, tag = "1")]
383    pub interval_in_milliseconds: u32,
384}
385#[allow(clippy::derive_partial_eq_without_eq)]
386#[derive(Clone, PartialEq, ::prost::Message)]
387pub struct TipsMetric {
388    #[prost(uint32, tag = "1")]
389    pub non_lazy_pool_size: u32,
390    #[prost(uint32, tag = "2")]
391    pub semi_lazy_pool_size: u32,
392}
393/// UTXO
394#[allow(clippy::derive_partial_eq_without_eq)]
395#[derive(Clone, PartialEq, ::prost::Message)]
396pub struct TransactionId {
397    #[prost(bytes = "vec", tag = "1")]
398    pub id: ::prost::alloc::vec::Vec<u8>,
399}
400#[allow(clippy::derive_partial_eq_without_eq)]
401#[derive(Clone, PartialEq, ::prost::Message)]
402pub struct OutputId {
403    #[prost(bytes = "vec", tag = "1")]
404    pub id: ::prost::alloc::vec::Vec<u8>,
405}
406#[allow(clippy::derive_partial_eq_without_eq)]
407#[derive(Clone, PartialEq, ::prost::Message)]
408pub struct OutputResponse {
409    #[prost(uint32, tag = "1")]
410    pub ledger_index: u32,
411    #[prost(oneof = "output_response::Payload", tags = "2, 3")]
412    pub payload: ::core::option::Option<output_response::Payload>,
413}
414/// Nested message and enum types in `OutputResponse`.
415pub mod output_response {
416    #[allow(clippy::derive_partial_eq_without_eq)]
417    #[derive(Clone, PartialEq, ::prost::Oneof)]
418    pub enum Payload {
419        #[prost(message, tag = "2")]
420        Output(super::LedgerOutput),
421        #[prost(message, tag = "3")]
422        Spent(super::LedgerSpent),
423    }
424}
425#[allow(clippy::derive_partial_eq_without_eq)]
426#[derive(Clone, PartialEq, ::prost::Message)]
427pub struct UnspentOutput {
428    #[prost(uint32, tag = "1")]
429    pub ledger_index: u32,
430    #[prost(message, optional, tag = "2")]
431    pub output: ::core::option::Option<LedgerOutput>,
432}
433#[allow(clippy::derive_partial_eq_without_eq)]
434#[derive(Clone, PartialEq, ::prost::Message)]
435pub struct RawOutput {
436    #[prost(bytes = "vec", tag = "1")]
437    pub data: ::prost::alloc::vec::Vec<u8>,
438}
439#[allow(clippy::derive_partial_eq_without_eq)]
440#[derive(Clone, PartialEq, ::prost::Message)]
441pub struct LedgerOutput {
442    #[prost(message, optional, tag = "1")]
443    pub output_id: ::core::option::Option<OutputId>,
444    #[prost(message, optional, tag = "2")]
445    pub block_id: ::core::option::Option<BlockId>,
446    #[prost(uint32, tag = "3")]
447    pub milestone_index_booked: u32,
448    #[prost(uint32, tag = "4")]
449    pub milestone_timestamp_booked: u32,
450    #[prost(message, optional, tag = "5")]
451    pub output: ::core::option::Option<RawOutput>,
452}
453#[allow(clippy::derive_partial_eq_without_eq)]
454#[derive(Clone, PartialEq, ::prost::Message)]
455pub struct LedgerSpent {
456    #[prost(message, optional, tag = "1")]
457    pub output: ::core::option::Option<LedgerOutput>,
458    #[prost(message, optional, tag = "2")]
459    pub transaction_id_spent: ::core::option::Option<TransactionId>,
460    #[prost(uint32, tag = "3")]
461    pub milestone_index_spent: u32,
462    #[prost(uint32, tag = "4")]
463    pub milestone_timestamp_spent: u32,
464}
465#[allow(clippy::derive_partial_eq_without_eq)]
466#[derive(Clone, PartialEq, ::prost::Message)]
467pub struct TreasuryOutput {
468    #[prost(message, optional, tag = "1")]
469    pub milestone_id: ::core::option::Option<MilestoneId>,
470    #[prost(uint64, tag = "2")]
471    pub amount: u64,
472}
473#[allow(clippy::derive_partial_eq_without_eq)]
474#[derive(Clone, PartialEq, ::prost::Message)]
475pub struct LedgerUpdate {
476    #[prost(oneof = "ledger_update::Op", tags = "1, 2, 3")]
477    pub op: ::core::option::Option<ledger_update::Op>,
478}
479/// Nested message and enum types in `LedgerUpdate`.
480pub mod ledger_update {
481    #[allow(clippy::derive_partial_eq_without_eq)]
482    #[derive(Clone, PartialEq, ::prost::Message)]
483    pub struct Marker {
484        #[prost(uint32, tag = "1")]
485        pub milestone_index: u32,
486        #[prost(enumeration = "marker::MarkerType", tag = "2")]
487        pub marker_type: i32,
488        #[prost(uint32, tag = "3")]
489        pub consumed_count: u32,
490        #[prost(uint32, tag = "4")]
491        pub created_count: u32,
492    }
493    /// Nested message and enum types in `Marker`.
494    pub mod marker {
495        #[derive(
496            Clone,
497            Copy,
498            Debug,
499            PartialEq,
500            Eq,
501            Hash,
502            PartialOrd,
503            Ord,
504            ::prost::Enumeration
505        )]
506        #[repr(i32)]
507        pub enum MarkerType {
508            Begin = 0,
509            End = 1,
510        }
511        impl MarkerType {
512            /// String value of the enum field names used in the ProtoBuf definition.
513            ///
514            /// The values are not transformed in any way and thus are considered stable
515            /// (if the ProtoBuf definition does not change) and safe for programmatic use.
516            pub fn as_str_name(&self) -> &'static str {
517                match self {
518                    MarkerType::Begin => "BEGIN",
519                    MarkerType::End => "END",
520                }
521            }
522            /// Creates an enum from field names used in the ProtoBuf definition.
523            pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
524                match value {
525                    "BEGIN" => Some(Self::Begin),
526                    "END" => Some(Self::End),
527                    _ => None,
528                }
529            }
530        }
531    }
532    #[allow(clippy::derive_partial_eq_without_eq)]
533    #[derive(Clone, PartialEq, ::prost::Oneof)]
534    pub enum Op {
535        #[prost(message, tag = "1")]
536        BatchMarker(Marker),
537        #[prost(message, tag = "2")]
538        Consumed(super::LedgerSpent),
539        #[prost(message, tag = "3")]
540        Created(super::LedgerOutput),
541    }
542}
543#[allow(clippy::derive_partial_eq_without_eq)]
544#[derive(Clone, PartialEq, ::prost::Message)]
545pub struct TreasuryUpdate {
546    #[prost(uint32, tag = "1")]
547    pub milestone_index: u32,
548    #[prost(message, optional, tag = "2")]
549    pub created: ::core::option::Option<TreasuryOutput>,
550    #[prost(message, optional, tag = "3")]
551    pub consumed: ::core::option::Option<TreasuryOutput>,
552}
553#[allow(clippy::derive_partial_eq_without_eq)]
554#[derive(Clone, PartialEq, ::prost::Message)]
555pub struct RawReceipt {
556    #[prost(bytes = "vec", tag = "1")]
557    pub data: ::prost::alloc::vec::Vec<u8>,
558}
559/// REST API
560#[allow(clippy::derive_partial_eq_without_eq)]
561#[derive(Clone, PartialEq, ::prost::Message)]
562pub struct ApiRouteRequest {
563    #[prost(string, tag = "1")]
564    pub route: ::prost::alloc::string::String,
565    #[prost(string, tag = "2")]
566    pub host: ::prost::alloc::string::String,
567    #[prost(uint32, tag = "3")]
568    pub port: u32,
569}
570#[allow(clippy::derive_partial_eq_without_eq)]
571#[derive(Clone, PartialEq, ::prost::Message)]
572pub struct ApiRequest {
573    #[prost(string, tag = "1")]
574    pub method: ::prost::alloc::string::String,
575    #[prost(string, tag = "2")]
576    pub path: ::prost::alloc::string::String,
577    #[prost(map = "string, string", tag = "3")]
578    pub headers: ::std::collections::HashMap<
579        ::prost::alloc::string::String,
580        ::prost::alloc::string::String,
581    >,
582    #[prost(bytes = "vec", tag = "4")]
583    pub body: ::prost::alloc::vec::Vec<u8>,
584}
585#[allow(clippy::derive_partial_eq_without_eq)]
586#[derive(Clone, PartialEq, ::prost::Message)]
587pub struct ApiResponse {
588    #[prost(uint32, tag = "1")]
589    pub code: u32,
590    #[prost(map = "string, string", tag = "2")]
591    pub headers: ::std::collections::HashMap<
592        ::prost::alloc::string::String,
593        ::prost::alloc::string::String,
594    >,
595    #[prost(bytes = "vec", tag = "3")]
596    pub body: ::prost::alloc::vec::Vec<u8>,
597}
598/// Generated client implementations.
599pub mod inx_client {
600    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
601    use tonic::codegen::*;
602    use tonic::codegen::http::Uri;
603    #[derive(Debug, Clone)]
604    pub struct InxClient<T> {
605        inner: tonic::client::Grpc<T>,
606    }
607    impl InxClient<tonic::transport::Channel> {
608        /// Attempt to create a new client by connecting to a given endpoint.
609        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
610        where
611            D: std::convert::TryInto<tonic::transport::Endpoint>,
612            D::Error: Into<StdError>,
613        {
614            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
615            Ok(Self::new(conn))
616        }
617    }
618    impl<T> InxClient<T>
619    where
620        T: tonic::client::GrpcService<tonic::body::BoxBody>,
621        T::Error: Into<StdError>,
622        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
623        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
624    {
625        pub fn new(inner: T) -> Self {
626            let inner = tonic::client::Grpc::new(inner);
627            Self { inner }
628        }
629        pub fn with_origin(inner: T, origin: Uri) -> Self {
630            let inner = tonic::client::Grpc::with_origin(inner, origin);
631            Self { inner }
632        }
633        pub fn with_interceptor<F>(
634            inner: T,
635            interceptor: F,
636        ) -> InxClient<InterceptedService<T, F>>
637        where
638            F: tonic::service::Interceptor,
639            T::ResponseBody: Default,
640            T: tonic::codegen::Service<
641                http::Request<tonic::body::BoxBody>,
642                Response = http::Response<
643                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
644                >,
645            >,
646            <T as tonic::codegen::Service<
647                http::Request<tonic::body::BoxBody>,
648            >>::Error: Into<StdError> + Send + Sync,
649        {
650            InxClient::new(InterceptedService::new(inner, interceptor))
651        }
652        /// Compress requests with the given encoding.
653        ///
654        /// This requires the server to support it otherwise it might respond with an
655        /// error.
656        #[must_use]
657        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
658            self.inner = self.inner.send_compressed(encoding);
659            self
660        }
661        /// Enable decompressing responses.
662        #[must_use]
663        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
664            self.inner = self.inner.accept_compressed(encoding);
665            self
666        }
667        /// Node
668        pub async fn read_node_status(
669            &mut self,
670            request: impl tonic::IntoRequest<super::NoParams>,
671        ) -> Result<tonic::Response<super::NodeStatus>, tonic::Status> {
672            self.inner
673                .ready()
674                .await
675                .map_err(|e| {
676                    tonic::Status::new(
677                        tonic::Code::Unknown,
678                        format!("Service was not ready: {}", e.into()),
679                    )
680                })?;
681            let codec = tonic::codec::ProstCodec::default();
682            let path = http::uri::PathAndQuery::from_static("/inx.INX/ReadNodeStatus");
683            self.inner.unary(request.into_request(), path, codec).await
684        }
685        pub async fn listen_to_node_status(
686            &mut self,
687            request: impl tonic::IntoRequest<super::NodeStatusRequest>,
688        ) -> Result<
689            tonic::Response<tonic::codec::Streaming<super::NodeStatus>>,
690            tonic::Status,
691        > {
692            self.inner
693                .ready()
694                .await
695                .map_err(|e| {
696                    tonic::Status::new(
697                        tonic::Code::Unknown,
698                        format!("Service was not ready: {}", e.into()),
699                    )
700                })?;
701            let codec = tonic::codec::ProstCodec::default();
702            let path = http::uri::PathAndQuery::from_static(
703                "/inx.INX/ListenToNodeStatus",
704            );
705            self.inner.server_streaming(request.into_request(), path, codec).await
706        }
707        pub async fn read_node_configuration(
708            &mut self,
709            request: impl tonic::IntoRequest<super::NoParams>,
710        ) -> Result<tonic::Response<super::NodeConfiguration>, tonic::Status> {
711            self.inner
712                .ready()
713                .await
714                .map_err(|e| {
715                    tonic::Status::new(
716                        tonic::Code::Unknown,
717                        format!("Service was not ready: {}", e.into()),
718                    )
719                })?;
720            let codec = tonic::codec::ProstCodec::default();
721            let path = http::uri::PathAndQuery::from_static(
722                "/inx.INX/ReadNodeConfiguration",
723            );
724            self.inner.unary(request.into_request(), path, codec).await
725        }
726        pub async fn read_protocol_parameters(
727            &mut self,
728            request: impl tonic::IntoRequest<super::MilestoneRequest>,
729        ) -> Result<tonic::Response<super::RawProtocolParameters>, tonic::Status> {
730            self.inner
731                .ready()
732                .await
733                .map_err(|e| {
734                    tonic::Status::new(
735                        tonic::Code::Unknown,
736                        format!("Service was not ready: {}", e.into()),
737                    )
738                })?;
739            let codec = tonic::codec::ProstCodec::default();
740            let path = http::uri::PathAndQuery::from_static(
741                "/inx.INX/ReadProtocolParameters",
742            );
743            self.inner.unary(request.into_request(), path, codec).await
744        }
745        /// Milestones
746        pub async fn read_milestone(
747            &mut self,
748            request: impl tonic::IntoRequest<super::MilestoneRequest>,
749        ) -> Result<tonic::Response<super::Milestone>, tonic::Status> {
750            self.inner
751                .ready()
752                .await
753                .map_err(|e| {
754                    tonic::Status::new(
755                        tonic::Code::Unknown,
756                        format!("Service was not ready: {}", e.into()),
757                    )
758                })?;
759            let codec = tonic::codec::ProstCodec::default();
760            let path = http::uri::PathAndQuery::from_static("/inx.INX/ReadMilestone");
761            self.inner.unary(request.into_request(), path, codec).await
762        }
763        pub async fn listen_to_latest_milestones(
764            &mut self,
765            request: impl tonic::IntoRequest<super::NoParams>,
766        ) -> Result<
767            tonic::Response<tonic::codec::Streaming<super::Milestone>>,
768            tonic::Status,
769        > {
770            self.inner
771                .ready()
772                .await
773                .map_err(|e| {
774                    tonic::Status::new(
775                        tonic::Code::Unknown,
776                        format!("Service was not ready: {}", e.into()),
777                    )
778                })?;
779            let codec = tonic::codec::ProstCodec::default();
780            let path = http::uri::PathAndQuery::from_static(
781                "/inx.INX/ListenToLatestMilestones",
782            );
783            self.inner.server_streaming(request.into_request(), path, codec).await
784        }
785        pub async fn listen_to_confirmed_milestones(
786            &mut self,
787            request: impl tonic::IntoRequest<super::MilestoneRangeRequest>,
788        ) -> Result<
789            tonic::Response<
790                tonic::codec::Streaming<super::MilestoneAndProtocolParameters>,
791            >,
792            tonic::Status,
793        > {
794            self.inner
795                .ready()
796                .await
797                .map_err(|e| {
798                    tonic::Status::new(
799                        tonic::Code::Unknown,
800                        format!("Service was not ready: {}", e.into()),
801                    )
802                })?;
803            let codec = tonic::codec::ProstCodec::default();
804            let path = http::uri::PathAndQuery::from_static(
805                "/inx.INX/ListenToConfirmedMilestones",
806            );
807            self.inner.server_streaming(request.into_request(), path, codec).await
808        }
809        pub async fn compute_white_flag(
810            &mut self,
811            request: impl tonic::IntoRequest<super::WhiteFlagRequest>,
812        ) -> Result<tonic::Response<super::WhiteFlagResponse>, tonic::Status> {
813            self.inner
814                .ready()
815                .await
816                .map_err(|e| {
817                    tonic::Status::new(
818                        tonic::Code::Unknown,
819                        format!("Service was not ready: {}", e.into()),
820                    )
821                })?;
822            let codec = tonic::codec::ProstCodec::default();
823            let path = http::uri::PathAndQuery::from_static("/inx.INX/ComputeWhiteFlag");
824            self.inner.unary(request.into_request(), path, codec).await
825        }
826        pub async fn read_milestone_cone(
827            &mut self,
828            request: impl tonic::IntoRequest<super::MilestoneRequest>,
829        ) -> Result<
830            tonic::Response<tonic::codec::Streaming<super::BlockWithMetadata>>,
831            tonic::Status,
832        > {
833            self.inner
834                .ready()
835                .await
836                .map_err(|e| {
837                    tonic::Status::new(
838                        tonic::Code::Unknown,
839                        format!("Service was not ready: {}", e.into()),
840                    )
841                })?;
842            let codec = tonic::codec::ProstCodec::default();
843            let path = http::uri::PathAndQuery::from_static(
844                "/inx.INX/ReadMilestoneCone",
845            );
846            self.inner.server_streaming(request.into_request(), path, codec).await
847        }
848        pub async fn read_milestone_cone_metadata(
849            &mut self,
850            request: impl tonic::IntoRequest<super::MilestoneRequest>,
851        ) -> Result<
852            tonic::Response<tonic::codec::Streaming<super::BlockMetadata>>,
853            tonic::Status,
854        > {
855            self.inner
856                .ready()
857                .await
858                .map_err(|e| {
859                    tonic::Status::new(
860                        tonic::Code::Unknown,
861                        format!("Service was not ready: {}", e.into()),
862                    )
863                })?;
864            let codec = tonic::codec::ProstCodec::default();
865            let path = http::uri::PathAndQuery::from_static(
866                "/inx.INX/ReadMilestoneConeMetadata",
867            );
868            self.inner.server_streaming(request.into_request(), path, codec).await
869        }
870        /// Blocks
871        pub async fn listen_to_blocks(
872            &mut self,
873            request: impl tonic::IntoRequest<super::NoParams>,
874        ) -> Result<
875            tonic::Response<tonic::codec::Streaming<super::Block>>,
876            tonic::Status,
877        > {
878            self.inner
879                .ready()
880                .await
881                .map_err(|e| {
882                    tonic::Status::new(
883                        tonic::Code::Unknown,
884                        format!("Service was not ready: {}", e.into()),
885                    )
886                })?;
887            let codec = tonic::codec::ProstCodec::default();
888            let path = http::uri::PathAndQuery::from_static("/inx.INX/ListenToBlocks");
889            self.inner.server_streaming(request.into_request(), path, codec).await
890        }
891        pub async fn listen_to_solid_blocks(
892            &mut self,
893            request: impl tonic::IntoRequest<super::NoParams>,
894        ) -> Result<
895            tonic::Response<tonic::codec::Streaming<super::BlockMetadata>>,
896            tonic::Status,
897        > {
898            self.inner
899                .ready()
900                .await
901                .map_err(|e| {
902                    tonic::Status::new(
903                        tonic::Code::Unknown,
904                        format!("Service was not ready: {}", e.into()),
905                    )
906                })?;
907            let codec = tonic::codec::ProstCodec::default();
908            let path = http::uri::PathAndQuery::from_static(
909                "/inx.INX/ListenToSolidBlocks",
910            );
911            self.inner.server_streaming(request.into_request(), path, codec).await
912        }
913        pub async fn listen_to_referenced_blocks(
914            &mut self,
915            request: impl tonic::IntoRequest<super::NoParams>,
916        ) -> Result<
917            tonic::Response<tonic::codec::Streaming<super::BlockMetadata>>,
918            tonic::Status,
919        > {
920            self.inner
921                .ready()
922                .await
923                .map_err(|e| {
924                    tonic::Status::new(
925                        tonic::Code::Unknown,
926                        format!("Service was not ready: {}", e.into()),
927                    )
928                })?;
929            let codec = tonic::codec::ProstCodec::default();
930            let path = http::uri::PathAndQuery::from_static(
931                "/inx.INX/ListenToReferencedBlocks",
932            );
933            self.inner.server_streaming(request.into_request(), path, codec).await
934        }
935        pub async fn submit_block(
936            &mut self,
937            request: impl tonic::IntoRequest<super::RawBlock>,
938        ) -> Result<tonic::Response<super::BlockId>, tonic::Status> {
939            self.inner
940                .ready()
941                .await
942                .map_err(|e| {
943                    tonic::Status::new(
944                        tonic::Code::Unknown,
945                        format!("Service was not ready: {}", e.into()),
946                    )
947                })?;
948            let codec = tonic::codec::ProstCodec::default();
949            let path = http::uri::PathAndQuery::from_static("/inx.INX/SubmitBlock");
950            self.inner.unary(request.into_request(), path, codec).await
951        }
952        pub async fn read_block(
953            &mut self,
954            request: impl tonic::IntoRequest<super::BlockId>,
955        ) -> Result<tonic::Response<super::RawBlock>, tonic::Status> {
956            self.inner
957                .ready()
958                .await
959                .map_err(|e| {
960                    tonic::Status::new(
961                        tonic::Code::Unknown,
962                        format!("Service was not ready: {}", e.into()),
963                    )
964                })?;
965            let codec = tonic::codec::ProstCodec::default();
966            let path = http::uri::PathAndQuery::from_static("/inx.INX/ReadBlock");
967            self.inner.unary(request.into_request(), path, codec).await
968        }
969        pub async fn read_block_metadata(
970            &mut self,
971            request: impl tonic::IntoRequest<super::BlockId>,
972        ) -> Result<tonic::Response<super::BlockMetadata>, tonic::Status> {
973            self.inner
974                .ready()
975                .await
976                .map_err(|e| {
977                    tonic::Status::new(
978                        tonic::Code::Unknown,
979                        format!("Service was not ready: {}", e.into()),
980                    )
981                })?;
982            let codec = tonic::codec::ProstCodec::default();
983            let path = http::uri::PathAndQuery::from_static(
984                "/inx.INX/ReadBlockMetadata",
985            );
986            self.inner.unary(request.into_request(), path, codec).await
987        }
988        /// Tips
989        pub async fn request_tips(
990            &mut self,
991            request: impl tonic::IntoRequest<super::TipsRequest>,
992        ) -> Result<tonic::Response<super::TipsResponse>, tonic::Status> {
993            self.inner
994                .ready()
995                .await
996                .map_err(|e| {
997                    tonic::Status::new(
998                        tonic::Code::Unknown,
999                        format!("Service was not ready: {}", e.into()),
1000                    )
1001                })?;
1002            let codec = tonic::codec::ProstCodec::default();
1003            let path = http::uri::PathAndQuery::from_static("/inx.INX/RequestTips");
1004            self.inner.unary(request.into_request(), path, codec).await
1005        }
1006        pub async fn listen_to_tips_metrics(
1007            &mut self,
1008            request: impl tonic::IntoRequest<super::TipsMetricRequest>,
1009        ) -> Result<
1010            tonic::Response<tonic::codec::Streaming<super::TipsMetric>>,
1011            tonic::Status,
1012        > {
1013            self.inner
1014                .ready()
1015                .await
1016                .map_err(|e| {
1017                    tonic::Status::new(
1018                        tonic::Code::Unknown,
1019                        format!("Service was not ready: {}", e.into()),
1020                    )
1021                })?;
1022            let codec = tonic::codec::ProstCodec::default();
1023            let path = http::uri::PathAndQuery::from_static(
1024                "/inx.INX/ListenToTipsMetrics",
1025            );
1026            self.inner.server_streaming(request.into_request(), path, codec).await
1027        }
1028        pub async fn listen_to_tip_score_updates(
1029            &mut self,
1030            request: impl tonic::IntoRequest<super::NoParams>,
1031        ) -> Result<
1032            tonic::Response<tonic::codec::Streaming<super::BlockMetadata>>,
1033            tonic::Status,
1034        > {
1035            self.inner
1036                .ready()
1037                .await
1038                .map_err(|e| {
1039                    tonic::Status::new(
1040                        tonic::Code::Unknown,
1041                        format!("Service was not ready: {}", e.into()),
1042                    )
1043                })?;
1044            let codec = tonic::codec::ProstCodec::default();
1045            let path = http::uri::PathAndQuery::from_static(
1046                "/inx.INX/ListenToTipScoreUpdates",
1047            );
1048            self.inner.server_streaming(request.into_request(), path, codec).await
1049        }
1050        /// UTXO
1051        pub async fn read_unspent_outputs(
1052            &mut self,
1053            request: impl tonic::IntoRequest<super::NoParams>,
1054        ) -> Result<
1055            tonic::Response<tonic::codec::Streaming<super::UnspentOutput>>,
1056            tonic::Status,
1057        > {
1058            self.inner
1059                .ready()
1060                .await
1061                .map_err(|e| {
1062                    tonic::Status::new(
1063                        tonic::Code::Unknown,
1064                        format!("Service was not ready: {}", e.into()),
1065                    )
1066                })?;
1067            let codec = tonic::codec::ProstCodec::default();
1068            let path = http::uri::PathAndQuery::from_static(
1069                "/inx.INX/ReadUnspentOutputs",
1070            );
1071            self.inner.server_streaming(request.into_request(), path, codec).await
1072        }
1073        /// A stream that yields updates to the ledger. A `LedgerUpdate` represents a batch to be applied to the ledger.
1074        /// It first sends a `BEGIN`, then all the consumed outputs, then all the created outputs and finally an `END`.
1075        /// `BEGIN` and `END` will also be sent for milestones that did not mutate the ledger.
1076        /// The counts in the batch markers can be used to sanity check that everything arrived and to pre-allocate space if needed.
1077        pub async fn listen_to_ledger_updates(
1078            &mut self,
1079            request: impl tonic::IntoRequest<super::MilestoneRangeRequest>,
1080        ) -> Result<
1081            tonic::Response<tonic::codec::Streaming<super::LedgerUpdate>>,
1082            tonic::Status,
1083        > {
1084            self.inner
1085                .ready()
1086                .await
1087                .map_err(|e| {
1088                    tonic::Status::new(
1089                        tonic::Code::Unknown,
1090                        format!("Service was not ready: {}", e.into()),
1091                    )
1092                })?;
1093            let codec = tonic::codec::ProstCodec::default();
1094            let path = http::uri::PathAndQuery::from_static(
1095                "/inx.INX/ListenToLedgerUpdates",
1096            );
1097            self.inner.server_streaming(request.into_request(), path, codec).await
1098        }
1099        pub async fn listen_to_treasury_updates(
1100            &mut self,
1101            request: impl tonic::IntoRequest<super::MilestoneRangeRequest>,
1102        ) -> Result<
1103            tonic::Response<tonic::codec::Streaming<super::TreasuryUpdate>>,
1104            tonic::Status,
1105        > {
1106            self.inner
1107                .ready()
1108                .await
1109                .map_err(|e| {
1110                    tonic::Status::new(
1111                        tonic::Code::Unknown,
1112                        format!("Service was not ready: {}", e.into()),
1113                    )
1114                })?;
1115            let codec = tonic::codec::ProstCodec::default();
1116            let path = http::uri::PathAndQuery::from_static(
1117                "/inx.INX/ListenToTreasuryUpdates",
1118            );
1119            self.inner.server_streaming(request.into_request(), path, codec).await
1120        }
1121        pub async fn read_output(
1122            &mut self,
1123            request: impl tonic::IntoRequest<super::OutputId>,
1124        ) -> Result<tonic::Response<super::OutputResponse>, tonic::Status> {
1125            self.inner
1126                .ready()
1127                .await
1128                .map_err(|e| {
1129                    tonic::Status::new(
1130                        tonic::Code::Unknown,
1131                        format!("Service was not ready: {}", e.into()),
1132                    )
1133                })?;
1134            let codec = tonic::codec::ProstCodec::default();
1135            let path = http::uri::PathAndQuery::from_static("/inx.INX/ReadOutput");
1136            self.inner.unary(request.into_request(), path, codec).await
1137        }
1138        pub async fn listen_to_migration_receipts(
1139            &mut self,
1140            request: impl tonic::IntoRequest<super::NoParams>,
1141        ) -> Result<
1142            tonic::Response<tonic::codec::Streaming<super::RawReceipt>>,
1143            tonic::Status,
1144        > {
1145            self.inner
1146                .ready()
1147                .await
1148                .map_err(|e| {
1149                    tonic::Status::new(
1150                        tonic::Code::Unknown,
1151                        format!("Service was not ready: {}", e.into()),
1152                    )
1153                })?;
1154            let codec = tonic::codec::ProstCodec::default();
1155            let path = http::uri::PathAndQuery::from_static(
1156                "/inx.INX/ListenToMigrationReceipts",
1157            );
1158            self.inner.server_streaming(request.into_request(), path, codec).await
1159        }
1160        /// REST API
1161        pub async fn register_api_route(
1162            &mut self,
1163            request: impl tonic::IntoRequest<super::ApiRouteRequest>,
1164        ) -> Result<tonic::Response<super::NoParams>, tonic::Status> {
1165            self.inner
1166                .ready()
1167                .await
1168                .map_err(|e| {
1169                    tonic::Status::new(
1170                        tonic::Code::Unknown,
1171                        format!("Service was not ready: {}", e.into()),
1172                    )
1173                })?;
1174            let codec = tonic::codec::ProstCodec::default();
1175            let path = http::uri::PathAndQuery::from_static("/inx.INX/RegisterAPIRoute");
1176            self.inner.unary(request.into_request(), path, codec).await
1177        }
1178        pub async fn unregister_api_route(
1179            &mut self,
1180            request: impl tonic::IntoRequest<super::ApiRouteRequest>,
1181        ) -> Result<tonic::Response<super::NoParams>, tonic::Status> {
1182            self.inner
1183                .ready()
1184                .await
1185                .map_err(|e| {
1186                    tonic::Status::new(
1187                        tonic::Code::Unknown,
1188                        format!("Service was not ready: {}", e.into()),
1189                    )
1190                })?;
1191            let codec = tonic::codec::ProstCodec::default();
1192            let path = http::uri::PathAndQuery::from_static(
1193                "/inx.INX/UnregisterAPIRoute",
1194            );
1195            self.inner.unary(request.into_request(), path, codec).await
1196        }
1197        pub async fn perform_api_request(
1198            &mut self,
1199            request: impl tonic::IntoRequest<super::ApiRequest>,
1200        ) -> Result<tonic::Response<super::ApiResponse>, tonic::Status> {
1201            self.inner
1202                .ready()
1203                .await
1204                .map_err(|e| {
1205                    tonic::Status::new(
1206                        tonic::Code::Unknown,
1207                        format!("Service was not ready: {}", e.into()),
1208                    )
1209                })?;
1210            let codec = tonic::codec::ProstCodec::default();
1211            let path = http::uri::PathAndQuery::from_static(
1212                "/inx.INX/PerformAPIRequest",
1213            );
1214            self.inner.unary(request.into_request(), path, codec).await
1215        }
1216    }
1217}
inx/opt/rustwide/target/x86_64-unknown-linux-gnu/debug/build/inx-438cae180b119e48/out/inx.rs

inx/opt/rustwide/target/x86_64-unknown-linux-gnu/debug/build/inx-438cae180b119e48/out/
inx.rs
