From 281cf7a287b29a3cd62b5a0a6ab5ca506c89ad92 Mon Sep 17 00:00:00 2001 From: Nishk Patel Date: Wed, 7 Oct 2026 17:29:37 +0000 Subject: [PATCH] votor: replace votor messages with receive and serde fixtures --- Cargo.lock | 2 +- Cargo.toml | 2 +- proto/votor.options | 32 +- proto/votor.proto | 246 ++++++------- src/generated/file_descriptor_set.bin | Bin 66905 -> 64566 bytes src/generated/org.solana.sealevel.v1.rs | 437 +++++++++--------------- 6 files changed, 287 insertions(+), 432 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 9aa92b9..eedf678 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -399,7 +399,7 @@ dependencies = [ [[package]] name = "protosol" -version = "18.0.0" +version = "19.0.0" dependencies = [ "prost", "prost-build", diff --git a/Cargo.toml b/Cargo.toml index b7ca46f..aef9ee5 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "protosol" -version = "18.0.0" +version = "19.0.0" edition = "2021" license = "Apache-2.0" description = "Protobuf definitions for the SVM fuzzing project." diff --git a/proto/votor.options b/proto/votor.options index 5a09d23..6d418d0 100644 --- a/proto/votor.options +++ b/proto/votor.options @@ -1,24 +1,28 @@ votor.proto package:"fd_exec_test" votor.proto include:"../../../../ballet/nanopb/pb_firedancer.h" -fd_exec_test.VotorBlockId.block_hash max_size:32 fixed_length:true +fd_exec_test.VotorVote.block_id max_size:32 fixed_length:true +fd_exec_test.VotorVote.signature max_size:192 fixed_length:true -fd_exec_test.VotorBlockVote.block_hash max_size:32 fixed_length:true +fd_exec_test.VotorCert.block_id max_size:32 fixed_length:true +fd_exec_test.VotorCert.primary_bitmap max_size:253 +fd_exec_test.VotorCert.fallback_bitmap max_size:253 +fd_exec_test.VotorCert.signature max_size:192 fixed_length:true -fd_exec_test.VotorContext.validators type:FT_POINTER -fd_exec_test.VotorContext.key_seed max_size:32 fixed_length:true -fd_exec_test.VotorContext.actions type:FT_POINTER +fd_exec_test.VotorReceiveCert.block_id max_size:32 fixed_length:true +fd_exec_test.VotorReceiveCert.primary_bitmap max_size:253 +fd_exec_test.VotorReceiveCert.fallback_bitmap max_size:253 -fd_exec_test.VotorAggSig.signers type:FT_POINTER +fd_exec_test.VotorDatagram.data max_size:1280 -fd_exec_test.VotorBlockCert.block_hash max_size:32 fixed_length:true +fd_exec_test.VotorReceiveContext.datagrams type:FT_POINTER +fd_exec_test.VotorReceiveContext.validator_stakes max_count:16 -fd_exec_test.VotorNotarFallbackCert.block_hash max_size:32 fixed_length:true +fd_exec_test.VotorReceiveEffects.results type:FT_POINTER +fd_exec_test.VotorReceiveEffects.certs type:FT_POINTER +fd_exec_test.VotorReceiveEffects.banned type:FT_POINTER -fd_exec_test.VotorStandstill.certs type:FT_POINTER -fd_exec_test.VotorStandstill.votes type:FT_POINTER +fd_exec_test.VotorVoteSerializeEffects.wire max_size:236 +fd_exec_test.VotorVoteSerializeEffects.signing_payload max_size:43 -fd_exec_test.VotorActionResult.pool_events type:FT_POINTER -fd_exec_test.VotorActionResult.repair_requests type:FT_POINTER - -fd_exec_test.VotorEffects.results type:FT_POINTER +fd_exec_test.VotorCertSerializeEffects.wire max_size:1280 diff --git a/proto/votor.proto b/proto/votor.proto index 562dcb3..af0e721 100644 --- a/proto/votor.proto +++ b/proto/votor.proto @@ -3,166 +3,130 @@ package org.solana.sealevel.v1; import "metadata.proto"; -message VotorBlockId { - uint64 slot = 1; - bytes block_hash = 2; -} - -message VotorBlockVote { - uint64 slot = 1; - bytes block_hash = 2; - uint64 signer = 3; -} - -message VotorSlotVote { - uint64 slot = 1; - uint64 signer = 2; +/* Field numbers match the wire tags */ +enum VotorVoteKind { + VOTOR_VOTE_KIND_UNSPECIFIED = 0; + VOTOR_VOTE_KIND_NOTAR = 1; + VOTOR_VOTE_KIND_FINAL = 2; + VOTOR_VOTE_KIND_SKIP = 3; + VOTOR_VOTE_KIND_NOTAR_FALLBACK = 4; + VOTOR_VOTE_KIND_SKIP_FALLBACK = 5; } message VotorVote { - oneof vote { - VotorBlockVote notar = 1; - VotorBlockVote notar_fallback = 2; - VotorSlotVote skip = 3; - VotorSlotVote skip_fallback = 4; - VotorSlotVote final_vote = 5; - } -} - -message VotorValidator { - uint64 stake = 1; -} - -message VotorBlock { - VotorBlockId block = 1; - VotorBlockId parent = 2; -} - -message VotorAction { - oneof action { - VotorVote vote = 1; - VotorBlock block = 2; - bool standstill = 3; - } -} - -message VotorContext { - repeated VotorValidator validators = 1; - bytes key_seed = 2; - uint64 own_id = 3; - uint64 slot_offset = 4; - repeated VotorAction actions = 5; -} - -message VotorAggSig { - repeated uint64 signers = 2; -} - -message VotorBlockCert { - uint64 slot = 1; - bytes block_hash = 2; - VotorAggSig agg_sig = 3; - uint64 stake = 4; -} - -message VotorNotarFallbackCert { - uint64 slot = 1; - bytes block_hash = 2; - VotorAggSig agg_sig_notar = 3; - VotorAggSig agg_sig_notar_fallback = 4; - uint64 stake = 5; -} - -message VotorSkipCert { - uint64 slot = 1; - VotorAggSig agg_sig_skip = 2; - VotorAggSig agg_sig_skip_fallback = 3; - uint64 stake = 4; + VotorVoteKind kind = 1; + uint64 slot = 2; + /* Exactly 32 bytes; ignored for kinds that carry no block */ + bytes block_id = 3; + /* 192 bytes, an uncompressed G2 point, as on the wire */ + bytes signature = 4; } -message VotorFinalCert { - uint64 slot = 1; - VotorAggSig agg_sig = 2; - uint64 stake = 3; +/* Field numbers are the wire tag minus six */ +enum VotorCertKind { + VOTOR_CERT_KIND_UNSPECIFIED = 0; + VOTOR_CERT_KIND_FINAL = 1; + VOTOR_CERT_KIND_FAST_FINAL = 2; + VOTOR_CERT_KIND_NOTAR = 3; + VOTOR_CERT_KIND_NOTAR_FALLBACK = 4; + VOTOR_CERT_KIND_SKIP = 5; } message VotorCert { - oneof cert { - VotorBlockCert notar = 1; - VotorNotarFallbackCert notar_fallback = 2; - VotorSkipCert skip = 3; - VotorBlockCert fast_final = 4; - VotorFinalCert final_cert = 5; - } -} - -message VotorParentReady { - uint64 slot = 1; - VotorBlockId parent = 2; -} - -message VotorStandstill { - uint64 slot = 1; - repeated VotorCert certs = 2; - repeated VotorVote votes = 3; -} - -message VotorPoolEvent { - oneof event { - VotorParentReady parent_ready = 1; - VotorBlockId safe_to_notar = 2; - uint64 safe_to_skip = 3; - VotorCert cert_created = 4; - VotorStandstill standstill = 5; - } -} - -enum VotorAddVoteError { - VOTOR_ADD_VOTE_ERROR_OK = 0; - VOTOR_ADD_VOTE_ERROR_SLOT_OUT_OF_BOUNDS = 1; - VOTOR_ADD_VOTE_ERROR_DUPLICATE = 2; - VOTOR_ADD_VOTE_ERROR_SLASHABLE = 3; - VOTOR_ADD_VOTE_ERROR_UNKNOWN_SIGNER = 4; + VotorCertKind kind = 1; + uint64 slot = 2; + /* Exactly 32 bytes; zero for kinds that carry no block */ + bytes block_id = 3; + /* Base2 signer bitmaps by rank; fallback only for notar fallback and skip */ + bytes primary_bitmap = 4; + bytes fallback_bitmap = 5; + /* Aggregate signature, 192 bytes uncompressed, as on the wire */ + bytes signature = 6; +} + +/* Receive: datagrams run in order through each node's receive path and pool */ +message VotorDatagram { + /* Index into validator_stakes; out of range is an unknown sender */ + uint32 sender = 1; + /* Raw wire bytes, a vote or a cert */ + bytes data = 2; +} + +message VotorReceiveContext { + /* Processed in this order */ + repeated VotorDatagram datagrams = 1; + uint64 root_slot = 2; + uint32 shred_version = 3; + uint64 highest_parent_ready_slot = 4; + /* Stake of validator i (at most 16); its keys are fixed by the harness */ + repeated uint64 validator_stakes = 5; +} + +/* A cert the pool holds, with its signature as an 8-byte XXH64 hash (seed 0) */ +message VotorReceiveCert { + VotorCertKind kind = 1; + uint64 slot = 2; + /* Exactly 32 bytes; zero for kinds that carry no block */ + bytes block_id = 3; + /* Base2 signer bitmaps by rank; fallback only for notar fallback and skip */ + bytes primary_bitmap = 4; + bytes fallback_bitmap = 5; + fixed64 signature_hash = 6; +} + +message VotorReceiveEffects { + /* One per datagram: was it added to the consensus pool */ + repeated bool results = 1; + /* Certs the pool holds at the end, sorted by kind, slot, block_id */ + repeated VotorReceiveCert certs = 2; + /* Senders banned at the end, sorted */ + repeated uint32 banned = 3; +} + +message VotorReceiveFixture { + FixtureMetadata metadata = 1; + VotorReceiveContext input = 2; + VotorReceiveEffects output = 3; } -enum VotorSlashableOffence { - VOTOR_SLASHABLE_OFFENCE_UNSET = 0; - VOTOR_SLASHABLE_OFFENCE_NOTAR_DIFFERENT_HASH = 1; - VOTOR_SLASHABLE_OFFENCE_SKIP_AND_NOTARIZE = 2; - VOTOR_SLASHABLE_OFFENCE_SKIP_AND_FINALIZE = 3; - VOTOR_SLASHABLE_OFFENCE_NOTAR_FALLBACK_AND_FINALIZE = 4; +/* Vote serialize: the wire message and signing payload of a vote */ +message VotorVoteSerializeContext { + VotorVote vote = 1; + uint32 shred_version = 2; } -message VotorSlashable { - VotorSlashableOffence offence = 1; - uint64 validator = 2; - uint64 slot = 3; +message VotorVoteSerializeEffects { + /* Wire message as sent over QUIC */ + bytes wire = 1; + /* Bytes the BLS signature is computed over */ + bytes signing_payload = 2; + /* Not a vote production builds; nothing was serialized */ + bool skipped = 3; + /* The serializer rejected a vote production builds */ + bool refused = 4; } -message VotorActionResult { - VotorAddVoteError error = 1; - VotorSlashable slashable = 2; - repeated VotorPoolEvent pool_events = 3; - repeated VotorBlockId repair_requests = 4; +message VotorVoteSerializeFixture { + FixtureMetadata metadata = 1; + VotorVoteSerializeContext input = 2; + VotorVoteSerializeEffects output = 3; } -enum VotorRunStatus { - VOTOR_RUN_STATUS_UNSET = 0; - VOTOR_RUN_STATUS_OK = 1; - VOTOR_RUN_STATUS_PANIC = 2; - VOTOR_RUN_STATUS_INVALID_INPUT = 3; - VOTOR_RUN_STATUS_TIMEOUT = 4; +/* Cert serialize: the wire message of a cert */ +message VotorCertSerializeContext { + VotorCert cert = 1; + uint32 shred_version = 2; } -message VotorEffects { - VotorRunStatus status = 1; - repeated VotorActionResult results = 2; - uint64 finalized_slot = 3; - uint64 first_unpruned_slot = 4; +message VotorCertSerializeEffects { + /* Wire message as sent over QUIC */ + bytes wire = 1; + /* Not a cert a pool builds; nothing was serialized */ + bool skipped = 2; } -message VotorFixture { +message VotorCertSerializeFixture { FixtureMetadata metadata = 1; - VotorContext input = 2; - VotorEffects output = 3; + VotorCertSerializeContext input = 2; + VotorCertSerializeEffects output = 3; } diff --git a/src/generated/file_descriptor_set.bin b/src/generated/file_descriptor_set.bin index 4aa17bb8e9472e55687c050de8d845350240ec12..9250ce7fa7f678a3c29c4aaa181644ebc53f0214 100644 GIT binary patch delta 6969 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 BdrtrW diff --git a/src/generated/org.solana.sealevel.v1.rs b/src/generated/org.solana.sealevel.v1.rs index 81a83bf..4523409 100644 --- a/src/generated/org.solana.sealevel.v1.rs +++ b/src/generated/org.solana.sealevel.v1.rs @@ -1413,345 +1413,232 @@ pub struct VmSerializationFixture { pub output: ::core::option::Option, } #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct VotorBlockId { - #[prost(uint64, tag = "1")] +pub struct VotorVote { + #[prost(enumeration = "VotorVoteKind", tag = "1")] + pub kind: i32, + #[prost(uint64, tag = "2")] pub slot: u64, - #[prost(bytes = "vec", tag = "2")] - pub block_hash: ::prost::alloc::vec::Vec, + /// Exactly 32 bytes; ignored for kinds that carry no block + #[prost(bytes = "vec", tag = "3")] + pub block_id: ::prost::alloc::vec::Vec, + /// 192 bytes, an uncompressed G2 point, as on the wire + #[prost(bytes = "vec", tag = "4")] + pub signature: ::prost::alloc::vec::Vec, } #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct VotorBlockVote { - #[prost(uint64, tag = "1")] +pub struct VotorCert { + #[prost(enumeration = "VotorCertKind", tag = "1")] + pub kind: i32, + #[prost(uint64, tag = "2")] pub slot: u64, + /// Exactly 32 bytes; zero for kinds that carry no block + #[prost(bytes = "vec", tag = "3")] + pub block_id: ::prost::alloc::vec::Vec, + /// Base2 signer bitmaps by rank; fallback only for notar fallback and skip + #[prost(bytes = "vec", tag = "4")] + pub primary_bitmap: ::prost::alloc::vec::Vec, + #[prost(bytes = "vec", tag = "5")] + pub fallback_bitmap: ::prost::alloc::vec::Vec, + /// Aggregate signature, 192 bytes uncompressed, as on the wire + #[prost(bytes = "vec", tag = "6")] + pub signature: ::prost::alloc::vec::Vec, +} +/// Receive: datagrams run in order through each node's receive path and pool +#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] +pub struct VotorDatagram { + /// Index into validator_stakes; out of range is an unknown sender + #[prost(uint32, tag = "1")] + pub sender: u32, + /// Raw wire bytes, a vote or a cert #[prost(bytes = "vec", tag = "2")] - pub block_hash: ::prost::alloc::vec::Vec, - #[prost(uint64, tag = "3")] - pub signer: u64, + pub data: ::prost::alloc::vec::Vec, } -#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] -pub struct VotorSlotVote { - #[prost(uint64, tag = "1")] - pub slot: u64, +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct VotorReceiveContext { + /// Processed in this order + #[prost(message, repeated, tag = "1")] + pub datagrams: ::prost::alloc::vec::Vec, #[prost(uint64, tag = "2")] - pub signer: u64, + pub root_slot: u64, + #[prost(uint32, tag = "3")] + pub shred_version: u32, + #[prost(uint64, tag = "4")] + pub highest_parent_ready_slot: u64, + /// Stake of validator i (at most 16); its keys are fixed by the harness + #[prost(uint64, repeated, tag = "5")] + pub validator_stakes: ::prost::alloc::vec::Vec, } +/// A cert the pool holds, with its signature as an 8-byte XXH64 hash (seed 0) #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct VotorVote { - #[prost(oneof = "votor_vote::Vote", tags = "1, 2, 3, 4, 5")] - pub vote: ::core::option::Option, -} -/// Nested message and enum types in `VotorVote`. -pub mod votor_vote { - #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)] - pub enum Vote { - #[prost(message, tag = "1")] - Notar(super::VotorBlockVote), - #[prost(message, tag = "2")] - NotarFallback(super::VotorBlockVote), - #[prost(message, tag = "3")] - Skip(super::VotorSlotVote), - #[prost(message, tag = "4")] - SkipFallback(super::VotorSlotVote), - #[prost(message, tag = "5")] - FinalVote(super::VotorSlotVote), - } +pub struct VotorReceiveCert { + #[prost(enumeration = "VotorCertKind", tag = "1")] + pub kind: i32, + #[prost(uint64, tag = "2")] + pub slot: u64, + /// Exactly 32 bytes; zero for kinds that carry no block + #[prost(bytes = "vec", tag = "3")] + pub block_id: ::prost::alloc::vec::Vec, + /// Base2 signer bitmaps by rank; fallback only for notar fallback and skip + #[prost(bytes = "vec", tag = "4")] + pub primary_bitmap: ::prost::alloc::vec::Vec, + #[prost(bytes = "vec", tag = "5")] + pub fallback_bitmap: ::prost::alloc::vec::Vec, + #[prost(fixed64, tag = "6")] + pub signature_hash: u64, } -#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] -pub struct VotorValidator { - #[prost(uint64, tag = "1")] - pub stake: u64, +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct VotorReceiveEffects { + /// One per datagram: was it added to the consensus pool + #[prost(bool, repeated, tag = "1")] + pub results: ::prost::alloc::vec::Vec, + /// Certs the pool holds at the end, sorted by kind, slot, block_id + #[prost(message, repeated, tag = "2")] + pub certs: ::prost::alloc::vec::Vec, + /// Senders banned at the end, sorted + #[prost(uint32, repeated, tag = "3")] + pub banned: ::prost::alloc::vec::Vec, } -#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct VotorBlock { +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct VotorReceiveFixture { #[prost(message, optional, tag = "1")] - pub block: ::core::option::Option, + pub metadata: ::core::option::Option, #[prost(message, optional, tag = "2")] - pub parent: ::core::option::Option, -} -#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct VotorAction { - #[prost(oneof = "votor_action::Action", tags = "1, 2, 3")] - pub action: ::core::option::Option, -} -/// Nested message and enum types in `VotorAction`. -pub mod votor_action { - #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)] - pub enum Action { - #[prost(message, tag = "1")] - Vote(super::VotorVote), - #[prost(message, tag = "2")] - Block(super::VotorBlock), - #[prost(bool, tag = "3")] - Standstill(bool), - } -} -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct VotorContext { - #[prost(message, repeated, tag = "1")] - pub validators: ::prost::alloc::vec::Vec, - #[prost(bytes = "vec", tag = "2")] - pub key_seed: ::prost::alloc::vec::Vec, - #[prost(uint64, tag = "3")] - pub own_id: u64, - #[prost(uint64, tag = "4")] - pub slot_offset: u64, - #[prost(message, repeated, tag = "5")] - pub actions: ::prost::alloc::vec::Vec, -} -#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct VotorAggSig { - #[prost(uint64, repeated, tag = "2")] - pub signers: ::prost::alloc::vec::Vec, + pub input: ::core::option::Option, + #[prost(message, optional, tag = "3")] + pub output: ::core::option::Option, } +/// Vote serialize: the wire message and signing payload of a vote #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct VotorBlockCert { - #[prost(uint64, tag = "1")] - pub slot: u64, - #[prost(bytes = "vec", tag = "2")] - pub block_hash: ::prost::alloc::vec::Vec, - #[prost(message, optional, tag = "3")] - pub agg_sig: ::core::option::Option, - #[prost(uint64, tag = "4")] - pub stake: u64, +pub struct VotorVoteSerializeContext { + #[prost(message, optional, tag = "1")] + pub vote: ::core::option::Option, + #[prost(uint32, tag = "2")] + pub shred_version: u32, } #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct VotorNotarFallbackCert { - #[prost(uint64, tag = "1")] - pub slot: u64, +pub struct VotorVoteSerializeEffects { + /// Wire message as sent over QUIC + #[prost(bytes = "vec", tag = "1")] + pub wire: ::prost::alloc::vec::Vec, + /// Bytes the BLS signature is computed over #[prost(bytes = "vec", tag = "2")] - pub block_hash: ::prost::alloc::vec::Vec, - #[prost(message, optional, tag = "3")] - pub agg_sig_notar: ::core::option::Option, - #[prost(message, optional, tag = "4")] - pub agg_sig_notar_fallback: ::core::option::Option, - #[prost(uint64, tag = "5")] - pub stake: u64, + pub signing_payload: ::prost::alloc::vec::Vec, + /// Not a vote production builds; nothing was serialized + #[prost(bool, tag = "3")] + pub skipped: bool, + /// The serializer rejected a vote production builds + #[prost(bool, tag = "4")] + pub refused: bool, } #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct VotorSkipCert { - #[prost(uint64, tag = "1")] - pub slot: u64, +pub struct VotorVoteSerializeFixture { + #[prost(message, optional, tag = "1")] + pub metadata: ::core::option::Option, #[prost(message, optional, tag = "2")] - pub agg_sig_skip: ::core::option::Option, + pub input: ::core::option::Option, #[prost(message, optional, tag = "3")] - pub agg_sig_skip_fallback: ::core::option::Option, - #[prost(uint64, tag = "4")] - pub stake: u64, + pub output: ::core::option::Option, } +/// Cert serialize: the wire message of a cert #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct VotorFinalCert { - #[prost(uint64, tag = "1")] - pub slot: u64, - #[prost(message, optional, tag = "2")] - pub agg_sig: ::core::option::Option, - #[prost(uint64, tag = "3")] - pub stake: u64, +pub struct VotorCertSerializeContext { + #[prost(message, optional, tag = "1")] + pub cert: ::core::option::Option, + #[prost(uint32, tag = "2")] + pub shred_version: u32, } #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct VotorCert { - #[prost(oneof = "votor_cert::Cert", tags = "1, 2, 3, 4, 5")] - pub cert: ::core::option::Option, -} -/// Nested message and enum types in `VotorCert`. -pub mod votor_cert { - #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)] - pub enum Cert { - #[prost(message, tag = "1")] - Notar(super::VotorBlockCert), - #[prost(message, tag = "2")] - NotarFallback(super::VotorNotarFallbackCert), - #[prost(message, tag = "3")] - Skip(super::VotorSkipCert), - #[prost(message, tag = "4")] - FastFinal(super::VotorBlockCert), - #[prost(message, tag = "5")] - FinalCert(super::VotorFinalCert), - } +pub struct VotorCertSerializeEffects { + /// Wire message as sent over QUIC + #[prost(bytes = "vec", tag = "1")] + pub wire: ::prost::alloc::vec::Vec, + /// Not a cert a pool builds; nothing was serialized + #[prost(bool, tag = "2")] + pub skipped: bool, } #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] -pub struct VotorParentReady { - #[prost(uint64, tag = "1")] - pub slot: u64, - #[prost(message, optional, tag = "2")] - pub parent: ::core::option::Option, -} -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct VotorStandstill { - #[prost(uint64, tag = "1")] - pub slot: u64, - #[prost(message, repeated, tag = "2")] - pub certs: ::prost::alloc::vec::Vec, - #[prost(message, repeated, tag = "3")] - pub votes: ::prost::alloc::vec::Vec, -} -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct VotorPoolEvent { - #[prost(oneof = "votor_pool_event::Event", tags = "1, 2, 3, 4, 5")] - pub event: ::core::option::Option, -} -/// Nested message and enum types in `VotorPoolEvent`. -pub mod votor_pool_event { - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum Event { - #[prost(message, tag = "1")] - ParentReady(super::VotorParentReady), - #[prost(message, tag = "2")] - SafeToNotar(super::VotorBlockId), - #[prost(uint64, tag = "3")] - SafeToSkip(u64), - #[prost(message, tag = "4")] - CertCreated(super::VotorCert), - #[prost(message, tag = "5")] - Standstill(super::VotorStandstill), - } -} -#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] -pub struct VotorSlashable { - #[prost(enumeration = "VotorSlashableOffence", tag = "1")] - pub offence: i32, - #[prost(uint64, tag = "2")] - pub validator: u64, - #[prost(uint64, tag = "3")] - pub slot: u64, -} -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct VotorActionResult { - #[prost(enumeration = "VotorAddVoteError", tag = "1")] - pub error: i32, - #[prost(message, optional, tag = "2")] - pub slashable: ::core::option::Option, - #[prost(message, repeated, tag = "3")] - pub pool_events: ::prost::alloc::vec::Vec, - #[prost(message, repeated, tag = "4")] - pub repair_requests: ::prost::alloc::vec::Vec, -} -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct VotorEffects { - #[prost(enumeration = "VotorRunStatus", tag = "1")] - pub status: i32, - #[prost(message, repeated, tag = "2")] - pub results: ::prost::alloc::vec::Vec, - #[prost(uint64, tag = "3")] - pub finalized_slot: u64, - #[prost(uint64, tag = "4")] - pub first_unpruned_slot: u64, -} -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct VotorFixture { +pub struct VotorCertSerializeFixture { #[prost(message, optional, tag = "1")] pub metadata: ::core::option::Option, #[prost(message, optional, tag = "2")] - pub input: ::core::option::Option, + pub input: ::core::option::Option, #[prost(message, optional, tag = "3")] - pub output: ::core::option::Option, + pub output: ::core::option::Option, } +/// Field numbers match the wire tags #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] -pub enum VotorAddVoteError { - Ok = 0, - SlotOutOfBounds = 1, - Duplicate = 2, - Slashable = 3, - UnknownSigner = 4, -} -impl VotorAddVoteError { - /// String value of the enum field names used in the ProtoBuf definition. - /// - /// The values are not transformed in any way and thus are considered stable - /// (if the ProtoBuf definition does not change) and safe for programmatic use. - pub fn as_str_name(&self) -> &'static str { - match self { - Self::Ok => "VOTOR_ADD_VOTE_ERROR_OK", - Self::SlotOutOfBounds => "VOTOR_ADD_VOTE_ERROR_SLOT_OUT_OF_BOUNDS", - Self::Duplicate => "VOTOR_ADD_VOTE_ERROR_DUPLICATE", - Self::Slashable => "VOTOR_ADD_VOTE_ERROR_SLASHABLE", - Self::UnknownSigner => "VOTOR_ADD_VOTE_ERROR_UNKNOWN_SIGNER", - } - } - /// Creates an enum from field names used in the ProtoBuf definition. - pub fn from_str_name(value: &str) -> ::core::option::Option { - match value { - "VOTOR_ADD_VOTE_ERROR_OK" => Some(Self::Ok), - "VOTOR_ADD_VOTE_ERROR_SLOT_OUT_OF_BOUNDS" => Some(Self::SlotOutOfBounds), - "VOTOR_ADD_VOTE_ERROR_DUPLICATE" => Some(Self::Duplicate), - "VOTOR_ADD_VOTE_ERROR_SLASHABLE" => Some(Self::Slashable), - "VOTOR_ADD_VOTE_ERROR_UNKNOWN_SIGNER" => Some(Self::UnknownSigner), - _ => None, - } - } +pub enum VotorVoteKind { + Unspecified = 0, + Notar = 1, + Final = 2, + Skip = 3, + NotarFallback = 4, + SkipFallback = 5, } -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] -#[repr(i32)] -pub enum VotorSlashableOffence { - Unset = 0, - NotarDifferentHash = 1, - SkipAndNotarize = 2, - SkipAndFinalize = 3, - NotarFallbackAndFinalize = 4, -} -impl VotorSlashableOffence { +impl VotorVoteKind { /// String value of the enum field names used in the ProtoBuf definition. /// /// The values are not transformed in any way and thus are considered stable /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::Unset => "VOTOR_SLASHABLE_OFFENCE_UNSET", - Self::NotarDifferentHash => "VOTOR_SLASHABLE_OFFENCE_NOTAR_DIFFERENT_HASH", - Self::SkipAndNotarize => "VOTOR_SLASHABLE_OFFENCE_SKIP_AND_NOTARIZE", - Self::SkipAndFinalize => "VOTOR_SLASHABLE_OFFENCE_SKIP_AND_FINALIZE", - Self::NotarFallbackAndFinalize => { - "VOTOR_SLASHABLE_OFFENCE_NOTAR_FALLBACK_AND_FINALIZE" - } + Self::Unspecified => "VOTOR_VOTE_KIND_UNSPECIFIED", + Self::Notar => "VOTOR_VOTE_KIND_NOTAR", + Self::Final => "VOTOR_VOTE_KIND_FINAL", + Self::Skip => "VOTOR_VOTE_KIND_SKIP", + Self::NotarFallback => "VOTOR_VOTE_KIND_NOTAR_FALLBACK", + Self::SkipFallback => "VOTOR_VOTE_KIND_SKIP_FALLBACK", } } /// Creates an enum from field names used in the ProtoBuf definition. pub fn from_str_name(value: &str) -> ::core::option::Option { match value { - "VOTOR_SLASHABLE_OFFENCE_UNSET" => Some(Self::Unset), - "VOTOR_SLASHABLE_OFFENCE_NOTAR_DIFFERENT_HASH" => { - Some(Self::NotarDifferentHash) - } - "VOTOR_SLASHABLE_OFFENCE_SKIP_AND_NOTARIZE" => Some(Self::SkipAndNotarize), - "VOTOR_SLASHABLE_OFFENCE_SKIP_AND_FINALIZE" => Some(Self::SkipAndFinalize), - "VOTOR_SLASHABLE_OFFENCE_NOTAR_FALLBACK_AND_FINALIZE" => { - Some(Self::NotarFallbackAndFinalize) - } + "VOTOR_VOTE_KIND_UNSPECIFIED" => Some(Self::Unspecified), + "VOTOR_VOTE_KIND_NOTAR" => Some(Self::Notar), + "VOTOR_VOTE_KIND_FINAL" => Some(Self::Final), + "VOTOR_VOTE_KIND_SKIP" => Some(Self::Skip), + "VOTOR_VOTE_KIND_NOTAR_FALLBACK" => Some(Self::NotarFallback), + "VOTOR_VOTE_KIND_SKIP_FALLBACK" => Some(Self::SkipFallback), _ => None, } } } +/// Field numbers are the wire tag minus six #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] -pub enum VotorRunStatus { - Unset = 0, - Ok = 1, - Panic = 2, - InvalidInput = 3, - Timeout = 4, -} -impl VotorRunStatus { +pub enum VotorCertKind { + Unspecified = 0, + Final = 1, + FastFinal = 2, + Notar = 3, + NotarFallback = 4, + Skip = 5, +} +impl VotorCertKind { /// String value of the enum field names used in the ProtoBuf definition. /// /// The values are not transformed in any way and thus are considered stable /// (if the ProtoBuf definition does not change) and safe for programmatic use. pub fn as_str_name(&self) -> &'static str { match self { - Self::Unset => "VOTOR_RUN_STATUS_UNSET", - Self::Ok => "VOTOR_RUN_STATUS_OK", - Self::Panic => "VOTOR_RUN_STATUS_PANIC", - Self::InvalidInput => "VOTOR_RUN_STATUS_INVALID_INPUT", - Self::Timeout => "VOTOR_RUN_STATUS_TIMEOUT", + Self::Unspecified => "VOTOR_CERT_KIND_UNSPECIFIED", + Self::Final => "VOTOR_CERT_KIND_FINAL", + Self::FastFinal => "VOTOR_CERT_KIND_FAST_FINAL", + Self::Notar => "VOTOR_CERT_KIND_NOTAR", + Self::NotarFallback => "VOTOR_CERT_KIND_NOTAR_FALLBACK", + Self::Skip => "VOTOR_CERT_KIND_SKIP", } } /// Creates an enum from field names used in the ProtoBuf definition. pub fn from_str_name(value: &str) -> ::core::option::Option { match value { - "VOTOR_RUN_STATUS_UNSET" => Some(Self::Unset), - "VOTOR_RUN_STATUS_OK" => Some(Self::Ok), - "VOTOR_RUN_STATUS_PANIC" => Some(Self::Panic), - "VOTOR_RUN_STATUS_INVALID_INPUT" => Some(Self::InvalidInput), - "VOTOR_RUN_STATUS_TIMEOUT" => Some(Self::Timeout), + "VOTOR_CERT_KIND_UNSPECIFIED" => Some(Self::Unspecified), + "VOTOR_CERT_KIND_FINAL" => Some(Self::Final), + "VOTOR_CERT_KIND_FAST_FINAL" => Some(Self::FastFinal), + "VOTOR_CERT_KIND_NOTAR" => Some(Self::Notar), + "VOTOR_CERT_KIND_NOTAR_FALLBACK" => Some(Self::NotarFallback), + "VOTOR_CERT_KIND_SKIP" => Some(Self::Skip), _ => None, } }