serialization_api/
espresso.api.v2.rs

1// This file is @generated by prost-build.
2/// BLS public key (typically 48 bytes)
3#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
4#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
5pub struct BlsPublicKey {
6    #[prost(string, tag = "1")]
7    pub key: ::prost::alloc::string::String,
8}
9/// Schnorr public key (typically 32 bytes)
10#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
11#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
12pub struct SchnorrPublicKey {
13    #[prost(string, tag = "1")]
14    pub key: ::prost::alloc::string::String,
15}
16/// Network address - either IP or domain name with port
17#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
18#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
19pub struct NetAddr {
20    #[prost(oneof = "net_addr::AddrType", tags = "1, 2")]
21    pub addr_type: ::core::option::Option<net_addr::AddrType>,
22}
23/// Nested message and enum types in `NetAddr`.
24pub mod net_addr {
25    #[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
26    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
27    pub enum AddrType {
28        #[prost(message, tag = "1")]
29        Inet(super::InetAddr),
30        #[prost(message, tag = "2")]
31        Name(super::NameAddr),
32    }
33}
34/// IP address (v4 or v6) with port
35/// `host` is a socket-address-ready host string: plain dotted-decimal for IPv4
36/// (e.g. "192.0.2.1") and bracket-enclosed for IPv6 (e.g. "\[::1\]"), so that
37/// consumers can form a valid address with a simple "{host}:{port}" without
38/// inspecting the IP version.
39#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
40#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
41pub struct InetAddr {
42    #[prost(string, tag = "1")]
43    pub host: ::prost::alloc::string::String,
44    #[prost(uint32, tag = "2")]
45    pub port: u32,
46}
47/// Domain name with port
48#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
49#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
50pub struct NameAddr {
51    /// Domain name
52    #[prost(string, tag = "1")]
53    pub name: ::prost::alloc::string::String,
54    #[prost(uint32, tag = "2")]
55    pub port: u32,
56}
57/// Stake table entry for a validator
58#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
59#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
60pub struct StakeTableEntry {
61    /// BLS verification key
62    #[prost(message, optional, tag = "1")]
63    pub stake_key: ::core::option::Option<BlsPublicKey>,
64    /// U256 as decimal string
65    #[prost(string, tag = "2")]
66    pub stake_amount: ::prost::alloc::string::String,
67}
68/// Peer connection information
69#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
70#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
71pub struct PeerConnectInfo {
72    /// X25519 public key (32 bytes)
73    #[prost(string, tag = "1")]
74    pub x25519_key: ::prost::alloc::string::String,
75    /// P2P network address
76    #[prost(message, optional, tag = "2")]
77    pub p2p_addr: ::core::option::Option<NetAddr>,
78}
79/// Complete peer configuration
80#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
81#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
82pub struct PeerConfig {
83    /// Stake information
84    #[prost(message, optional, tag = "1")]
85    pub stake_table_entry: ::core::option::Option<StakeTableEntry>,
86    /// State verification key
87    #[prost(message, optional, tag = "2")]
88    pub state_ver_key: ::core::option::Option<SchnorrPublicKey>,
89    /// Optional connection info
90    #[prost(message, optional, tag = "3")]
91    pub connect_info: ::core::option::Option<PeerConnectInfo>,
92}
93/// U256 value encoded as hex string
94#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
95#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
96pub struct U256 {
97    /// Hex-encoded value with "0x" prefix (e.g., "0x32fe2fedb43f62b4ee2")
98    #[prost(string, tag = "1")]
99    pub value: ::prost::alloc::string::String,
100}
101/// Reward claim input for contract submission
102/// Contains all data needed to call the claimRewards function on the L1 contract
103#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
104#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
105pub struct RewardClaimInput {
106    /// Ethereum address of the reward recipient
107    #[prost(string, tag = "1")]
108    pub address: ::prost::alloc::string::String,
109    /// Total lifetime rewards for this address (hex-encoded with "0x" prefix for contract)
110    #[prost(string, tag = "2")]
111    pub lifetime_rewards: ::prost::alloc::string::String,
112    /// Auth data containing the Merkle proof and auth root inputs (hex-encoded with "0x" prefix)
113    /// This is the encoded RewardAuthData from the contract adapter
114    #[prost(string, tag = "3")]
115    pub auth_data: ::prost::alloc::string::String,
116}
117/// Request to get reward claim input (at latest finalized height)
118#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
119#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
120pub struct GetRewardClaimInputRequest {
121    /// Ethereum address to query rewards for (hex format, e.g. "0x1234...")
122    #[prost(string, tag = "1")]
123    #[schemars(example = "0x0000000000000000000000000000000000000000")]
124    pub address: ::prost::alloc::string::String,
125}
126/// Reward balance for an address
127#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
128#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
129pub struct RewardBalance {
130    /// Balance amount in wei (decimal string)
131    #[prost(string, tag = "1")]
132    pub amount: ::prost::alloc::string::String,
133}
134/// Request to get reward balance (at latest finalized height)
135#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
136#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
137pub struct GetRewardBalanceRequest {
138    /// Ethereum address to query
139    #[prost(string, tag = "1")]
140    #[schemars(example = "0x0000000000000000000000000000000000000000")]
141    pub address: ::prost::alloc::string::String,
142}
143/// Complete reward account query data with balance and merkle proof
144#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
145#[derive(Clone, PartialEq, ::prost::Message)]
146pub struct RewardAccountQueryDataV2 {
147    /// Current balance for this account (decimal string)
148    #[prost(string, tag = "1")]
149    pub balance: ::prost::alloc::string::String,
150    /// Merkle proof for this account
151    #[prost(message, optional, tag = "2")]
152    pub proof: ::core::option::Option<RewardAccountProofV2>,
153}
154/// Reward account proof containing account address and merkle path
155#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
156#[derive(Clone, PartialEq, ::prost::Message)]
157pub struct RewardAccountProofV2 {
158    /// Ethereum address of the account
159    #[prost(string, tag = "1")]
160    pub account: ::prost::alloc::string::String,
161    /// Merkle proof (Presence or Absence)
162    #[prost(message, optional, tag = "2")]
163    pub proof: ::core::option::Option<RewardMerkleProofV2>,
164}
165/// Merkle proof variant (Presence for existing accounts, Absence for non-existing)
166#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
167#[derive(Clone, PartialEq, ::prost::Message)]
168pub struct RewardMerkleProofV2 {
169    #[prost(oneof = "reward_merkle_proof_v2::ProofType", tags = "1, 2")]
170    pub proof_type: ::core::option::Option<reward_merkle_proof_v2::ProofType>,
171}
172/// Nested message and enum types in `RewardMerkleProofV2`.
173pub mod reward_merkle_proof_v2 {
174    #[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
175    #[derive(Clone, PartialEq, ::prost::Oneof)]
176    pub enum ProofType {
177        #[prost(message, tag = "1")]
178        Presence(super::MerkleProof),
179        #[prost(message, tag = "2")]
180        Absence(super::MerkleProof),
181    }
182}
183/// Merkle proof containing leaf position and path to root
184#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
185#[derive(Clone, PartialEq, ::prost::Message)]
186pub struct MerkleProof {
187    /// Leaf position (account address), TaggedBase64 format
188    #[prost(string, tag = "1")]
189    pub pos: ::prost::alloc::string::String,
190    /// Merkle path from leaf to root (160 levels for binary tree)
191    #[prost(message, repeated, tag = "2")]
192    pub proof: ::prost::alloc::vec::Vec<MerkleNode>,
193}
194/// Merkle tree node (one of four variants)
195#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
196#[derive(Clone, PartialEq, ::prost::Message)]
197pub struct MerkleNode {
198    #[prost(oneof = "merkle_node::NodeType", tags = "1, 2, 3, 4")]
199    pub node_type: ::core::option::Option<merkle_node::NodeType>,
200}
201/// Nested message and enum types in `MerkleNode`.
202pub mod merkle_node {
203    #[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
204    #[derive(Clone, PartialEq, ::prost::Oneof)]
205    pub enum NodeType {
206        #[prost(message, tag = "1")]
207        Empty(super::Empty),
208        #[prost(message, tag = "2")]
209        Leaf(super::Leaf),
210        #[prost(message, tag = "3")]
211        Branch(super::Branch),
212        #[prost(message, tag = "4")]
213        ForgottenSubtree(super::ForgottenSubtree),
214    }
215}
216/// Dummy message for flattening Empty
217#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
218#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
219pub struct EmptyData {}
220/// Empty node variant (no data)
221#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
222#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
223pub struct Empty {
224    /// Dummy field for serde flatten compatibility (must be a message type)
225    #[prost(message, optional, tag = "1")]
226    #[serde(skip)]
227    pub dummy: ::core::option::Option<EmptyData>,
228}
229/// Leaf node containing account and reward amount
230#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
231#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
232pub struct Leaf {
233    /// Leaf position (account address), TaggedBase64 format
234    #[prost(string, tag = "1")]
235    pub pos: ::prost::alloc::string::String,
236    /// Reward amount (U256), TaggedBase64 format
237    #[prost(string, tag = "2")]
238    pub elem: ::prost::alloc::string::String,
239    /// Node hash value, TaggedBase64 format
240    #[prost(string, tag = "3")]
241    pub value: ::prost::alloc::string::String,
242}
243/// Branch node with hash and children
244#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
245#[derive(Clone, PartialEq, ::prost::Message)]
246pub struct Branch {
247    /// Hash value, TaggedBase64 format
248    #[prost(string, tag = "1")]
249    pub value: ::prost::alloc::string::String,
250    /// Child nodes (up to 2 for binary tree)
251    #[prost(message, repeated, tag = "2")]
252    pub children: ::prost::alloc::vec::Vec<MerkleNode>,
253}
254/// Forgotten subtree node with hash only
255#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
256#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
257pub struct ForgottenSubtree {
258    /// Hash value, TaggedBase64 format
259    #[prost(string, tag = "1")]
260    pub value: ::prost::alloc::string::String,
261}
262/// Request to get reward account proof (at latest finalized height)
263#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
264#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
265pub struct GetRewardAccountProofRequest {
266    /// Ethereum address to query
267    #[prost(string, tag = "1")]
268    #[schemars(example = "0x0000000000000000000000000000000000000000")]
269    pub address: ::prost::alloc::string::String,
270}
271/// Single reward amount entry
272#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
273#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
274pub struct RewardAmount {
275    /// Ethereum address
276    #[prost(string, tag = "1")]
277    pub address: ::prost::alloc::string::String,
278    /// Reward amount in wei (decimal string)
279    #[prost(string, tag = "2")]
280    pub amount: ::prost::alloc::string::String,
281}
282/// Paginated list of reward balances
283#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
284#[derive(Clone, PartialEq, ::prost::Message)]
285pub struct RewardBalances {
286    /// List of reward amounts in this page
287    #[prost(message, repeated, tag = "1")]
288    pub amounts: ::prost::alloc::vec::Vec<RewardAmount>,
289    /// Total number of accounts with rewards at this height
290    #[prost(uint64, tag = "2")]
291    pub total: u64,
292}
293/// Request to get paginated reward balances
294#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
295#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
296pub struct GetRewardBalancesRequest {
297    /// Block height to query
298    #[prost(uint64, tag = "1")]
299    #[schemars(example = "1000000")]
300    pub height: u64,
301    /// Starting offset for pagination
302    #[prost(uint64, tag = "2")]
303    #[schemars(example = "0")]
304    pub offset: u64,
305    /// Maximum number of results (limit ≤ 10000)
306    #[prost(uint64, tag = "3")]
307    #[schemars(example = "100")]
308    pub limit: u64,
309}
310/// Raw RewardMerkleTreeV2 snapshot data
311#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
312#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
313pub struct RewardMerkleTreeV2Data {
314    /// Serialized merkle tree data
315    #[prost(bytes = "vec", tag = "1")]
316    pub data: ::prost::alloc::vec::Vec<u8>,
317}
318/// Request to get reward merkle tree snapshot
319#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
320#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
321pub struct GetRewardMerkleTreeRequest {
322    /// Block height to query
323    #[prost(uint64, tag = "1")]
324    #[schemars(example = "1000000")]
325    pub height: u64,
326}
327/// ADVZ (VID V0) namespace proof
328#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
329#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
330pub struct AdvzNsProof {
331    #[prost(uint64, tag = "1")]
332    pub namespace_id: u64,
333    #[prost(string, tag = "2")]
334    pub ns_payload: ::prost::alloc::string::String,
335    /// VID proof (serialized)
336    #[prost(string, optional, tag = "3")]
337    pub ns_proof: ::core::option::Option<::prost::alloc::string::String>,
338}
339/// AvidM (VID V1) namespace proof
340#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
341#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
342pub struct AvidMNsProof {
343    #[prost(uint64, tag = "1")]
344    pub ns_index: u64,
345    #[prost(string, tag = "2")]
346    pub ns_payload: ::prost::alloc::string::String,
347    /// Merkle proof (serialized)
348    #[prost(string, tag = "3")]
349    pub ns_proof: ::prost::alloc::string::String,
350}
351/// AvidM incorrect encoding proof
352#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
353#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
354pub struct AvidMIncorrectEncodingNsProof {
355    /// Serialized incorrect encoding proof
356    #[prost(string, tag = "1")]
357    pub proof_data: ::prost::alloc::string::String,
358}
359/// AvidmGf2 (VID V2) namespace proof
360#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
361#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
362pub struct AvidmGf2NsProof {
363    #[prost(uint64, tag = "1")]
364    pub ns_index: u64,
365    #[prost(string, tag = "2")]
366    pub ns_payload: ::prost::alloc::string::String,
367    /// Merkle proof (serialized)
368    #[prost(string, tag = "3")]
369    pub ns_proof: ::prost::alloc::string::String,
370}
371/// Namespace proof - supports multiple VID versions
372#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
373#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
374pub struct NsProof {
375    #[prost(oneof = "ns_proof::ProofVersion", tags = "1, 2, 3, 4")]
376    pub proof_version: ::core::option::Option<ns_proof::ProofVersion>,
377}
378/// Nested message and enum types in `NsProof`.
379pub mod ns_proof {
380    #[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
381    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
382    pub enum ProofVersion {
383        #[prost(message, tag = "1")]
384        V0(super::AdvzNsProof),
385        #[prost(message, tag = "2")]
386        V1(super::AvidMNsProof),
387        #[prost(message, tag = "3")]
388        V1IncorrectEncoding(super::AvidMIncorrectEncodingNsProof),
389        #[prost(message, tag = "4")]
390        V2(super::AvidmGf2NsProof),
391    }
392}
393/// Request to get namespace proof(s)
394/// Either specify 'block' for a single block, or 'first' and 'last' for a range
395#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
396#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
397pub struct GetNamespaceProofRequest {
398    /// Namespace ID
399    #[prost(uint64, tag = "1")]
400    #[schemars(example = "10001")]
401    pub namespace_id: u64,
402    /// Single block query
403    #[prost(uint64, optional, tag = "2")]
404    #[schemars(example = "1000000")]
405    pub block: ::core::option::Option<u64>,
406    /// Range query - first block (inclusive)
407    #[prost(uint64, optional, tag = "3")]
408    #[schemars(example = "1000000")]
409    pub first: ::core::option::Option<u64>,
410    /// Range query - last block (inclusive)
411    #[prost(uint64, optional, tag = "4")]
412    #[schemars(example = "1000100")]
413    pub last: ::core::option::Option<u64>,
414}
415/// Transaction
416#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
417#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
418pub struct Transaction {
419    #[prost(uint64, tag = "1")]
420    pub namespace: u64,
421    /// base64 encoded
422    #[prost(string, tag = "2")]
423    pub payload: ::prost::alloc::string::String,
424}
425/// Single block namespace proof response
426#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
427#[derive(Clone, PartialEq, ::prost::Message)]
428pub struct NamespaceProofResponse {
429    /// Transactions for this namespace
430    #[prost(message, repeated, tag = "1")]
431    pub transactions: ::prost::alloc::vec::Vec<Transaction>,
432    /// Namespace proof (optional - may be None if namespace not present)
433    #[prost(message, optional, tag = "2")]
434    pub proof: ::core::option::Option<NsProof>,
435}
436/// Response for range queries - array of namespace proofs
437#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
438#[derive(Clone, PartialEq, ::prost::Message)]
439pub struct NamespaceProofRangeResponse {
440    /// Proofs for each block in the range
441    #[prost(message, repeated, tag = "1")]
442    pub proofs: ::prost::alloc::vec::Vec<NamespaceProofResponse>,
443}
444/// Unified response for namespace proof queries
445#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
446#[derive(Clone, PartialEq, ::prost::Message)]
447pub struct GetNamespaceProofResponse {
448    #[prost(oneof = "get_namespace_proof_response::Response", tags = "1, 2")]
449    pub response: ::core::option::Option<get_namespace_proof_response::Response>,
450}
451/// Nested message and enum types in `GetNamespaceProofResponse`.
452pub mod get_namespace_proof_response {
453    #[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
454    #[derive(Clone, PartialEq, ::prost::Oneof)]
455    pub enum Response {
456        /// Single block response
457        #[prost(message, tag = "1")]
458        Single(super::NamespaceProofResponse),
459        /// Range response
460        #[prost(message, tag = "2")]
461        Range(super::NamespaceProofRangeResponse),
462    }
463}
464/// Request to get incorrect encoding proof
465#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
466#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
467pub struct GetIncorrectEncodingProofRequest {
468    /// Namespace ID
469    #[prost(uint64, tag = "1")]
470    #[schemars(example = "10001")]
471    pub namespace_id: u64,
472    /// Block height
473    #[prost(uint64, tag = "2")]
474    #[schemars(example = "1000000")]
475    pub block_height: u64,
476}
477/// Incorrect encoding proof response
478#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
479#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
480pub struct IncorrectEncodingProofResponse {
481    /// Incorrect encoding proof (AvidM V1.1 proof)
482    #[prost(message, optional, tag = "1")]
483    pub proof: ::core::option::Option<AvidMIncorrectEncodingNsProof>,
484}
485/// Light client state
486#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
487#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
488pub struct LightClientState {
489    #[prost(uint64, tag = "1")]
490    pub view_number: u64,
491    #[prost(uint64, tag = "2")]
492    pub block_height: u64,
493    /// CircuitField serialized as bytes
494    #[prost(string, tag = "3")]
495    pub block_comm_root: ::prost::alloc::string::String,
496}
497/// Stake table state commitments
498#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
499#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
500pub struct StakeTableState {
501    /// CircuitField as bytes
502    #[prost(string, tag = "1")]
503    pub bls_key_comm: ::prost::alloc::string::String,
504    /// CircuitField as bytes
505    #[prost(string, tag = "2")]
506    pub schnorr_key_comm: ::prost::alloc::string::String,
507    /// CircuitField as bytes
508    #[prost(string, tag = "3")]
509    pub amount_comm: ::prost::alloc::string::String,
510    /// CircuitField as bytes
511    #[prost(string, tag = "4")]
512    pub threshold: ::prost::alloc::string::String,
513}
514/// State signature tuple (key + two signatures)
515#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
516#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
517pub struct StateSignatureTuple {
518    /// Schnorr public key
519    #[prost(message, optional, tag = "1")]
520    pub state_signature_key: ::core::option::Option<SchnorrPublicKey>,
521    /// LCV3 Schnorr signature
522    #[prost(string, tag = "2")]
523    pub lcv3_signature: ::prost::alloc::string::String,
524    /// LCV2 Schnorr signature
525    #[prost(string, tag = "3")]
526    pub lcv2_signature: ::prost::alloc::string::String,
527}
528/// Light client state update certificate V2
529#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
530#[derive(Clone, PartialEq, ::prost::Message)]
531pub struct LightClientStateUpdateCertificateV2 {
532    #[prost(uint64, tag = "1")]
533    pub epoch: u64,
534    /// TaggedBase64 "LIGHT_CLIENT_STATE~..."
535    #[prost(string, tag = "2")]
536    pub light_client_state: ::prost::alloc::string::String,
537    /// TaggedBase64 "STAKE_TABLE_STATE~..."
538    #[prost(string, tag = "3")]
539    pub next_stake_table_state: ::prost::alloc::string::String,
540    #[prost(message, repeated, tag = "4")]
541    pub signatures: ::prost::alloc::vec::Vec<StateSignatureTuple>,
542    /// TaggedBase64 or plain base64
543    #[prost(string, tag = "5")]
544    pub auth_root: ::prost::alloc::string::String,
545}
546/// Request to get state certificate for an epoch
547#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
548#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
549pub struct GetStateCertificateRequest {
550    /// Epoch number
551    #[prost(uint64, tag = "1")]
552    #[schemars(example = "100")]
553    pub epoch: u64,
554}
555/// State certificate response
556#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
557#[derive(Clone, PartialEq, ::prost::Message)]
558pub struct StateCertificateResponse {
559    /// Structured light client state update certificate
560    #[prost(message, optional, tag = "1")]
561    pub certificate: ::core::option::Option<LightClientStateUpdateCertificateV2>,
562}
563/// Request to get stake table for an epoch
564#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
565#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
566pub struct GetStakeTableRequest {
567    /// Epoch number
568    #[prost(uint64, tag = "1")]
569    #[schemars(example = "100")]
570    pub epoch: u64,
571}
572/// Stake table response
573#[derive(serde::Serialize, serde::Deserialize, schemars::JsonSchema)]
574#[derive(Clone, PartialEq, ::prost::Message)]
575pub struct StakeTableResponse {
576    /// List of peer configurations
577    #[prost(message, repeated, tag = "1")]
578    pub peers: ::prost::alloc::vec::Vec<PeerConfig>,
579}
serialization_api/espresso.api.v2.rs

serialization_api/
espresso.api.v2.rs
