diff --git a/Cargo.lock b/Cargo.lock index 4a8a8087eb..cb3f145775 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1514,6 +1514,7 @@ dependencies = [ "pbjson 0.5.1", "pin-project", "prost", + "regex", "rocksdb", "serde", "sha2 0.10.8", @@ -4692,6 +4693,7 @@ dependencies = [ "serde_json", "serde_with 1.14.0", "sha2 0.9.9", + "simple-base64", "tempfile", "tendermint", "tokio", @@ -7614,6 +7616,12 @@ dependencies = [ "rand_core 0.6.4", ] +[[package]] +name = "simple-base64" +version = "0.23.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6385ef05b7bbfddaa8bf6306d059adac087990d659576c73b7da802d9a6ce91f" + [[package]] name = "sized-chunks" version = "0.6.5" diff --git a/crates/bin/pcli/Cargo.toml b/crates/bin/pcli/Cargo.toml index 0f98adfde2..01e385b30b 100644 --- a/crates/bin/pcli/Cargo.toml +++ b/crates/bin/pcli/Cargo.toml @@ -16,7 +16,17 @@ default = ["std", "parallel", "download-proving-keys"] download-proving-keys = ["penumbra-proof-params/download-proving-keys"] sct-divergence-check = ["penumbra-view/sct-divergence-check"] std = ["ark-ff/std", "ibc-types/std"] -parallel = ["penumbra-proof-params/parallel", "decaf377/parallel", "penumbra-shielded-pool/parallel", "penumbra-dex/parallel", "penumbra-governance/parallel", "penumbra-stake/parallel", "penumbra-transaction/parallel", "penumbra-wallet/parallel", "penumbra-proof-setup/parallel"] +parallel = [ + "penumbra-proof-params/parallel", + "decaf377/parallel", + "penumbra-shielded-pool/parallel", + "penumbra-dex/parallel", + "penumbra-governance/parallel", + "penumbra-stake/parallel", + "penumbra-transaction/parallel", + "penumbra-wallet/parallel", + "penumbra-proof-setup/parallel", +] [dependencies] # Workspace dependencies @@ -60,6 +70,7 @@ async-stream = "0.2" bincode = "1.3.3" blake2b_simd = "0.5" base64 = "0.21" +simple-base64 = "0.23" bytes = "1" comfy-table = "5" directories = "4.0.1" diff --git a/crates/bin/pcli/src/command/query.rs b/crates/bin/pcli/src/command/query.rs index 110bc792f0..974a4592a9 100644 --- a/crates/bin/pcli/src/command/query.rs +++ b/crates/bin/pcli/src/command/query.rs @@ -1,4 +1,4 @@ -use anyhow::{Context, Result}; +use anyhow::{anyhow, Context, Result}; mod shielded_pool; use shielded_pool::ShieldedPool; @@ -61,10 +61,31 @@ pub enum QueryCmd { /// Queries information about IBC. #[clap(subcommand)] Ibc(IbcCmd), + /// Subscribes to a filtered stream of state changes. + Watch { + /// The regex to filter keys in verifiable storage. + /// + /// The empty string matches all keys; the pattern $^ matches no keys. + #[clap(long, default_value = "")] + key_regex: String, + /// The regex to filter keys in nonverifiable storage. + /// + /// The empty string matches all keys; the pattern $^ matches no keys. + #[clap(long, default_value = "")] + nv_key_regex: String, + }, } impl QueryCmd { pub async fn exec(&self, app: &mut App) -> Result<()> { + if let QueryCmd::Watch { + key_regex, + nv_key_regex, + } = self + { + return watch(key_regex.clone(), nv_key_regex.clone(), app).await; + } + // Special-case: this is a Tendermint query if let QueryCmd::Tx(tx) = self { return tx.exec(app).await; @@ -101,6 +122,7 @@ impl QueryCmd { | QueryCmd::Dex(_) | QueryCmd::Governance(_) | QueryCmd::Dao(_) + | QueryCmd::Watch { .. } | QueryCmd::Ibc(_) => { unreachable!("query handled in guard"); } @@ -138,6 +160,7 @@ impl QueryCmd { | QueryCmd::ShieldedPool { .. } | QueryCmd::Governance { .. } | QueryCmd::Key { .. } + | QueryCmd::Watch { .. } | QueryCmd::Ibc(_) => true, } } @@ -154,6 +177,7 @@ impl QueryCmd { | QueryCmd::Dex { .. } | QueryCmd::Governance { .. } | QueryCmd::Dao { .. } + | QueryCmd::Watch { .. } | QueryCmd::Ibc(_) => { unreachable!("query is special cased") } @@ -162,3 +186,57 @@ impl QueryCmd { Ok(()) } } + +// this code (not just this function, the whole module) is pretty shitty, +// but that's maybe okay for the moment. it exists to consume the rpc. +async fn watch(key_regex: String, nv_key_regex: String, app: &mut App) -> Result<()> { + use penumbra_proto::cnidarium::v1alpha1::{ + query_service_client::QueryServiceClient, watch_response as wr, + }; + let mut client = QueryServiceClient::new(app.pd_channel().await?); + + let req = penumbra_proto::cnidarium::v1alpha1::WatchRequest { + key_regex, + nv_key_regex, + }; + + tracing::debug!(?req); + + let mut stream = client.watch(req).await?.into_inner(); + + while let Some(rsp) = stream.message().await? { + match rsp.entry { + Some(wr::Entry::Kv(kv)) => { + if kv.deleted { + println!("{} KV {} -> DELETED", rsp.version, kv.key); + } else { + println!( + "{} KV {} -> {}", + rsp.version, + kv.key, + simple_base64::encode(&kv.value) + ); + } + } + Some(wr::Entry::NvKv(nv_kv)) => { + let key = simple_base64::encode(&nv_kv.key); + + if nv_kv.deleted { + println!("{} NVKV {} -> DELETED", rsp.version, key); + } else { + println!( + "{} NVKV {} -> {}", + rsp.version, + key, + simple_base64::encode(&nv_kv.value) + ); + } + } + None => { + return Err(anyhow!("server returned None event")); + } + } + } + + Ok(()) +} diff --git a/crates/cnidarium/Cargo.toml b/crates/cnidarium/Cargo.toml index d8b735d5ab..da4c345343 100644 --- a/crates/cnidarium/Cargo.toml +++ b/crates/cnidarium/Cargo.toml @@ -40,6 +40,7 @@ prost = { version = "0.12.3", optional = true } serde = { version = "1", optional = true } pbjson = { version = "0.5", optional = true } ibc-proto = { version = "0.39.0", default-features = false, features = ["serde"], optional = true } +regex = "1.10.2" [dev-dependencies] tempfile = "3.3.0" diff --git a/crates/cnidarium/src/cache.rs b/crates/cnidarium/src/cache.rs index 1a76c9dd6f..f9817d7716 100644 --- a/crates/cnidarium/src/cache.rs +++ b/crates/cnidarium/src/cache.rs @@ -23,6 +23,16 @@ pub struct Cache { } impl Cache { + /// Inspect the cache of unwritten changes to the verifiable state. + pub fn unwritten_changes(&self) -> &BTreeMap>> { + &self.unwritten_changes + } + + /// Inspect the cache of unwritten changes to the nonverifiable state. + pub fn nonverifiable_changes(&self) -> &BTreeMap, Option>> { + &self.nonverifiable_changes + } + /// Merge the given cache with this one, taking its writes in place of ours. pub fn merge(&mut self, other: Cache) { // One might ask, why does this exist separately from `apply_to`? The @@ -103,4 +113,13 @@ impl Cache { } changes_by_substore } + + pub(crate) fn clone_changes(&self) -> Self { + Self { + unwritten_changes: self.unwritten_changes.clone(), + nonverifiable_changes: self.nonverifiable_changes.clone(), + ephemeral_objects: Default::default(), + events: Default::default(), + } + } } diff --git a/crates/cnidarium/src/gen/penumbra.cnidarium.v1alpha1.rs b/crates/cnidarium/src/gen/penumbra.cnidarium.v1alpha1.rs index 6edd6f9cbc..33b0e9efef 100644 --- a/crates/cnidarium/src/gen/penumbra.cnidarium.v1alpha1.rs +++ b/crates/cnidarium/src/gen/penumbra.cnidarium.v1alpha1.rs @@ -91,6 +91,106 @@ impl ::prost::Name for PrefixValueResponse { ::prost::alloc::format!("penumbra.cnidarium.v1alpha1.{}", Self::NAME) } } +/// Requests a stream of new key-value pairs that have been committed to the state. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WatchRequest { + /// A regex for keys in the verifiable storage. + /// + /// Only key-value updates whose keys match this regex will be returned. + /// Note that the empty string matches all keys. + /// To exclude all keys, use the regex "$^", which matches no strings. + #[prost(string, tag = "1")] + pub key_regex: ::prost::alloc::string::String, + /// A regex for keys in the nonverifiable storage. + /// + /// Only key-value updates whose keys match this regex will be returned. + /// Note that the empty string matches all keys. + /// To exclude all keys, use the regex "$^", which matches no strings. + #[prost(string, tag = "2")] + pub nv_key_regex: ::prost::alloc::string::String, +} +impl ::prost::Name for WatchRequest { + const NAME: &'static str = "WatchRequest"; + const PACKAGE: &'static str = "penumbra.cnidarium.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("penumbra.cnidarium.v1alpha1.{}", Self::NAME) + } +} +/// A key-value pair that has been committed to the state. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WatchResponse { + /// The state version the key-value pair was committed at. + #[prost(uint64, tag = "1")] + pub version: u64, + /// The entry that was committed. + #[prost(oneof = "watch_response::Entry", tags = "5, 6")] + pub entry: ::core::option::Option, +} +/// Nested message and enum types in `WatchResponse`. +pub mod watch_response { + /// Elements of the verifiable storage have string keys. + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Message)] + pub struct KeyValue { + #[prost(string, tag = "1")] + pub key: ::prost::alloc::string::String, + #[prost(bytes = "vec", tag = "2")] + pub value: ::prost::alloc::vec::Vec, + /// If set to true, the key-value pair was deleted. + /// This allows distinguishing a deleted key-value pair from a key-value pair whose value is empty. + #[prost(bool, tag = "3")] + pub deleted: bool, + } + impl ::prost::Name for KeyValue { + const NAME: &'static str = "KeyValue"; + const PACKAGE: &'static str = "penumbra.cnidarium.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!( + "penumbra.cnidarium.v1alpha1.WatchResponse.{}", Self::NAME + ) + } + } + /// Elements of the nonverifiable storage have byte keys. + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Message)] + pub struct NvKeyValue { + #[prost(bytes = "vec", tag = "1")] + pub key: ::prost::alloc::vec::Vec, + #[prost(bytes = "vec", tag = "2")] + pub value: ::prost::alloc::vec::Vec, + /// If set to true, the key-value pair was deleted. + /// This allows distinguishing a deleted key-value pair from a key-value pair whose value is empty. + #[prost(bool, tag = "3")] + pub deleted: bool, + } + impl ::prost::Name for NvKeyValue { + const NAME: &'static str = "NvKeyValue"; + const PACKAGE: &'static str = "penumbra.cnidarium.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!( + "penumbra.cnidarium.v1alpha1.WatchResponse.{}", Self::NAME + ) + } + } + /// The entry that was committed. + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Entry { + #[prost(message, tag = "5")] + Kv(KeyValue), + #[prost(message, tag = "6")] + NvKv(NvKeyValue), + } +} +impl ::prost::Name for WatchResponse { + const NAME: &'static str = "WatchResponse"; + const PACKAGE: &'static str = "penumbra.cnidarium.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("penumbra.cnidarium.v1alpha1.{}", Self::NAME) + } +} /// Generated client implementations. #[cfg(feature = "rpc")] pub mod query_service_client { @@ -211,7 +311,6 @@ pub mod query_service_client { } /// General-purpose prefixed key-value state query API, that can be used to query /// arbitrary prefixes in the JMT storage. - /// Returns a stream of `PrefixValueResponse`s. pub async fn prefix_value( &mut self, request: impl tonic::IntoRequest, @@ -242,6 +341,34 @@ pub mod query_service_client { ); self.inner.server_streaming(req, path, codec).await } + /// Subscribes to a stream of key-value updates, with regex filtering on keys. + pub async fn watch( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response>, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/penumbra.cnidarium.v1alpha1.QueryService/Watch", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("penumbra.cnidarium.v1alpha1.QueryService", "Watch"), + ); + self.inner.server_streaming(req, path, codec).await + } } } /// Generated server implementations. @@ -269,7 +396,6 @@ pub mod query_service_server { + 'static; /// General-purpose prefixed key-value state query API, that can be used to query /// arbitrary prefixes in the JMT storage. - /// Returns a stream of `PrefixValueResponse`s. async fn prefix_value( &self, request: tonic::Request, @@ -277,6 +403,17 @@ pub mod query_service_server { tonic::Response, tonic::Status, >; + /// Server streaming response type for the Watch method. + type WatchStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + + Send + + 'static; + /// Subscribes to a stream of key-value updates, with regex filtering on keys. + async fn watch( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; } #[derive(Debug)] pub struct QueryServiceServer { @@ -450,6 +587,53 @@ pub mod query_service_server { }; Box::pin(fut) } + "/penumbra.cnidarium.v1alpha1.QueryService/Watch" => { + #[allow(non_camel_case_types)] + struct WatchSvc(pub Arc); + impl< + T: QueryService, + > tonic::server::ServerStreamingService + for WatchSvc { + type Response = super::WatchResponse; + type ResponseStream = T::WatchStream; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::watch(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = WatchSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } _ => { Box::pin(async move { Ok( diff --git a/crates/cnidarium/src/gen/penumbra.cnidarium.v1alpha1.serde.rs b/crates/cnidarium/src/gen/penumbra.cnidarium.v1alpha1.serde.rs index b762affecd..c3fb51ff5b 100644 --- a/crates/cnidarium/src/gen/penumbra.cnidarium.v1alpha1.serde.rs +++ b/crates/cnidarium/src/gen/penumbra.cnidarium.v1alpha1.serde.rs @@ -546,3 +546,502 @@ impl<'de> serde::Deserialize<'de> for PrefixValueResponse { deserializer.deserialize_struct("penumbra.cnidarium.v1alpha1.PrefixValueResponse", FIELDS, GeneratedVisitor) } } +impl serde::Serialize for WatchRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.key_regex.is_empty() { + len += 1; + } + if !self.nv_key_regex.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("penumbra.cnidarium.v1alpha1.WatchRequest", len)?; + if !self.key_regex.is_empty() { + struct_ser.serialize_field("keyRegex", &self.key_regex)?; + } + if !self.nv_key_regex.is_empty() { + struct_ser.serialize_field("nvKeyRegex", &self.nv_key_regex)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WatchRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "key_regex", + "keyRegex", + "nv_key_regex", + "nvKeyRegex", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + KeyRegex, + NvKeyRegex, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "keyRegex" | "key_regex" => Ok(GeneratedField::KeyRegex), + "nvKeyRegex" | "nv_key_regex" => Ok(GeneratedField::NvKeyRegex), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WatchRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct penumbra.cnidarium.v1alpha1.WatchRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut key_regex__ = None; + let mut nv_key_regex__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::KeyRegex => { + if key_regex__.is_some() { + return Err(serde::de::Error::duplicate_field("keyRegex")); + } + key_regex__ = Some(map_.next_value()?); + } + GeneratedField::NvKeyRegex => { + if nv_key_regex__.is_some() { + return Err(serde::de::Error::duplicate_field("nvKeyRegex")); + } + nv_key_regex__ = Some(map_.next_value()?); + } + } + } + Ok(WatchRequest { + key_regex: key_regex__.unwrap_or_default(), + nv_key_regex: nv_key_regex__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("penumbra.cnidarium.v1alpha1.WatchRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WatchResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.version != 0 { + len += 1; + } + if self.entry.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("penumbra.cnidarium.v1alpha1.WatchResponse", len)?; + if self.version != 0 { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?; + } + if let Some(v) = self.entry.as_ref() { + match v { + watch_response::Entry::Kv(v) => { + struct_ser.serialize_field("kv", v)?; + } + watch_response::Entry::NvKv(v) => { + struct_ser.serialize_field("nvKv", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WatchResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "version", + "kv", + "nv_kv", + "nvKv", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Version, + Kv, + NvKv, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "version" => Ok(GeneratedField::Version), + "kv" => Ok(GeneratedField::Kv), + "nvKv" | "nv_kv" => Ok(GeneratedField::NvKv), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WatchResponse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct penumbra.cnidarium.v1alpha1.WatchResponse") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut version__ = None; + let mut entry__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Version => { + if version__.is_some() { + return Err(serde::de::Error::duplicate_field("version")); + } + version__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Kv => { + if entry__.is_some() { + return Err(serde::de::Error::duplicate_field("kv")); + } + entry__ = map_.next_value::<::std::option::Option<_>>()?.map(watch_response::Entry::Kv) +; + } + GeneratedField::NvKv => { + if entry__.is_some() { + return Err(serde::de::Error::duplicate_field("nvKv")); + } + entry__ = map_.next_value::<::std::option::Option<_>>()?.map(watch_response::Entry::NvKv) +; + } + } + } + Ok(WatchResponse { + version: version__.unwrap_or_default(), + entry: entry__, + }) + } + } + deserializer.deserialize_struct("penumbra.cnidarium.v1alpha1.WatchResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for watch_response::KeyValue { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.key.is_empty() { + len += 1; + } + if !self.value.is_empty() { + len += 1; + } + if self.deleted { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("penumbra.cnidarium.v1alpha1.WatchResponse.KeyValue", len)?; + if !self.key.is_empty() { + struct_ser.serialize_field("key", &self.key)?; + } + if !self.value.is_empty() { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?; + } + if self.deleted { + struct_ser.serialize_field("deleted", &self.deleted)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for watch_response::KeyValue { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "key", + "value", + "deleted", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Key, + Value, + Deleted, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "key" => Ok(GeneratedField::Key), + "value" => Ok(GeneratedField::Value), + "deleted" => Ok(GeneratedField::Deleted), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = watch_response::KeyValue; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct penumbra.cnidarium.v1alpha1.WatchResponse.KeyValue") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut key__ = None; + let mut value__ = None; + let mut deleted__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Key => { + if key__.is_some() { + return Err(serde::de::Error::duplicate_field("key")); + } + key__ = Some(map_.next_value()?); + } + GeneratedField::Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("value")); + } + value__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::Deleted => { + if deleted__.is_some() { + return Err(serde::de::Error::duplicate_field("deleted")); + } + deleted__ = Some(map_.next_value()?); + } + } + } + Ok(watch_response::KeyValue { + key: key__.unwrap_or_default(), + value: value__.unwrap_or_default(), + deleted: deleted__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("penumbra.cnidarium.v1alpha1.WatchResponse.KeyValue", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for watch_response::NvKeyValue { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.key.is_empty() { + len += 1; + } + if !self.value.is_empty() { + len += 1; + } + if self.deleted { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("penumbra.cnidarium.v1alpha1.WatchResponse.NvKeyValue", len)?; + if !self.key.is_empty() { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("key", pbjson::private::base64::encode(&self.key).as_str())?; + } + if !self.value.is_empty() { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?; + } + if self.deleted { + struct_ser.serialize_field("deleted", &self.deleted)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for watch_response::NvKeyValue { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "key", + "value", + "deleted", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Key, + Value, + Deleted, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "key" => Ok(GeneratedField::Key), + "value" => Ok(GeneratedField::Value), + "deleted" => Ok(GeneratedField::Deleted), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = watch_response::NvKeyValue; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct penumbra.cnidarium.v1alpha1.WatchResponse.NvKeyValue") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut key__ = None; + let mut value__ = None; + let mut deleted__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Key => { + if key__.is_some() { + return Err(serde::de::Error::duplicate_field("key")); + } + key__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("value")); + } + value__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::Deleted => { + if deleted__.is_some() { + return Err(serde::de::Error::duplicate_field("deleted")); + } + deleted__ = Some(map_.next_value()?); + } + } + } + Ok(watch_response::NvKeyValue { + key: key__.unwrap_or_default(), + value: value__.unwrap_or_default(), + deleted: deleted__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("penumbra.cnidarium.v1alpha1.WatchResponse.NvKeyValue", FIELDS, GeneratedVisitor) + } +} diff --git a/crates/cnidarium/src/gen/proto_descriptor.bin.no_lfs b/crates/cnidarium/src/gen/proto_descriptor.bin.no_lfs index 5f11bb6b3b..ad8745ec01 100644 Binary files a/crates/cnidarium/src/gen/proto_descriptor.bin.no_lfs and b/crates/cnidarium/src/gen/proto_descriptor.bin.no_lfs differ diff --git a/crates/cnidarium/src/rpc.rs b/crates/cnidarium/src/rpc.rs index aab2097acb..b348cf60a6 100644 --- a/crates/cnidarium/src/rpc.rs +++ b/crates/cnidarium/src/rpc.rs @@ -23,14 +23,17 @@ use std::pin::Pin; use crate::read::StateRead; use crate::rpc::proto::v1alpha1::{ - key_value_response::Value, query_service_server::QueryService, KeyValueRequest, - KeyValueResponse, PrefixValueRequest, PrefixValueResponse, + key_value_response::Value, query_service_server::QueryService, watch_response as wr, + KeyValueRequest, KeyValueResponse, PrefixValueRequest, PrefixValueResponse, WatchRequest, + WatchResponse, }; use futures::{StreamExt, TryStreamExt}; +use tokio_stream::wrappers::ReceiverStream; use tonic::Status; use tracing::instrument; use crate::Storage; + #[tonic::async_trait] impl QueryService for Server { #[instrument(skip(self, request))] @@ -105,4 +108,84 @@ impl QueryService for Server { .boxed(), )) } + + type WatchStream = ReceiverStream>; + + #[instrument(skip(self, request))] + async fn watch( + &self, + request: tonic::Request, + ) -> Result, Status> { + let request = request.into_inner(); + tracing::debug!(?request); + + const MAX_REGEX_LEN: usize = 1024; + + let key_regex = regex::RegexBuilder::new(&request.key_regex) + .size_limit(MAX_REGEX_LEN) + .build() + .map_err(|e| Status::invalid_argument(format!("invalid key_regex: {}", e)))?; + + // Use the `bytes` regex to allow matching byte strings. + let nv_key_regex = regex::bytes::RegexBuilder::new(&request.key_regex) + .size_limit(MAX_REGEX_LEN) + .unicode(false) + .build() + .map_err(|e| Status::invalid_argument(format!("invalid nv_key_regex: {}", e)))?; + + let (tx, rx) = tokio::sync::mpsc::channel::>(10); + + tokio::spawn(watch_changes( + self.storage.clone(), + key_regex, + nv_key_regex, + tx, + )); + + Ok(tonic::Response::new(ReceiverStream::new(rx))) + } +} + +async fn watch_changes( + storage: Storage, + key_regex: regex::Regex, + nv_key_regex: regex::bytes::Regex, + tx: tokio::sync::mpsc::Sender>, +) -> anyhow::Result<()> { + let mut changes_rx = storage.subscribe_changes(); + loop { + // Wait for a new set of changes, reporting an error if we don't get one. + if let Err(e) = changes_rx.changed().await { + tx.send(Err(tonic::Status::internal(e.to_string()))).await?; + } + let (version, changes) = changes_rx.borrow_and_update().clone(); + + for (key, value) in changes.unwritten_changes().iter() { + if key_regex.is_match(key) { + tx.send(Ok(WatchResponse { + version, + entry: Some(wr::Entry::Kv(wr::KeyValue { + key: key.clone(), + value: value.as_ref().cloned().unwrap_or_default(), + deleted: value.is_none(), + })), + })) + .await?; + } + } + + for (key, value) in changes.nonverifiable_changes().iter() { + if nv_key_regex.is_match(key) { + tx.send(Ok(WatchResponse { + version, + entry: Some(wr::Entry::NvKv(wr::NvKeyValue { + key: key.clone(), + value: value.as_ref().cloned().unwrap_or_default(), + deleted: value.is_none(), + })), + })) + .await?; + } + } + } } diff --git a/crates/cnidarium/src/storage.rs b/crates/cnidarium/src/storage.rs index 71ab6e8e07..12450e5af6 100644 --- a/crates/cnidarium/src/storage.rs +++ b/crates/cnidarium/src/storage.rs @@ -35,8 +35,9 @@ impl std::fmt::Debug for Storage { // A private inner element to prevent the `TreeWriter` implementation // from leaking outside of this crate. struct Inner { - tx_dispatcher: watch::Sender, - tx_state: Arc>, + dispatcher_tx: watch::Sender<(Snapshot, (jmt::Version, Arc))>, + snapshot_rx: watch::Receiver, + changes_rx: watch::Receiver<(jmt::Version, Arc)>, snapshots: RwLock, multistore_config: MultistoreConfig, #[allow(dead_code)] @@ -187,29 +188,32 @@ impl Storage { // Setup a dispatcher task that acts as an intermediary between the storage // and the rest of the system. Its purpose is to forward new snapshots to // subscribers. + // // If we were to send snapshots directly to subscribers, a slow subscriber could // hold a lock on the watch channel for too long, and block the consensus-critical // commit logic, which needs to acquire a write lock on the watch channel. - // dispatcher channel (internal): - // - `tx_dispatcher` is used by storage to signal that a new snapshot is available. - // - `rx_dispatcher` is used by the dispatcher to receive new snapshots. - // snapshot channel (external): - // - `tx_state` is used by the dispatcher to signal new snapshots to the rest of the system. - // - `rx_state` is used by various components to subscribe to new snapshots. - let (tx_state, _) = watch::channel(latest_snapshot.clone()); - let (tx_dispatcher, mut rx_dispatcher) = watch::channel(latest_snapshot); - - let tx_state = Arc::new(tx_state); - let tx_state2 = tx_state.clone(); + // + // Instead, we "proxy" through a dispatcher task that copies values from one + // channel to the other, ensuring that if an API consumer misuses the watch + // channels, it will only affect other subscribers, not the commit logic. + + let (snapshot_tx, snapshot_rx) = watch::channel(latest_snapshot.clone()); + // Note: this will never be seen by consumers, since we mark the current value as seen + // before returning the receiver. + let dummy_cache = (u64::MAX, Arc::new(Cache::default())); + let (changes_tx, changes_rx) = watch::channel(dummy_cache.clone()); + let (tx_dispatcher, mut rx_dispatcher) = watch::channel((latest_snapshot, dummy_cache)); + let jh_dispatcher = tokio::spawn(async move { tracing::info!("snapshot dispatcher task has started"); // If the sender is dropped, the task will terminate. while rx_dispatcher.changed().await.is_ok() { tracing::debug!("dispatcher has received a new snapshot"); - let snapshot = rx_dispatcher.borrow_and_update().clone(); + let (snapshot, changes) = rx_dispatcher.borrow_and_update().clone(); // [`watch::Sender::send`] only returns an error if there are no // receivers, so we can safely ignore the result here. - let _ = tx_state2.send(snapshot); + let _ = snapshot_tx.send(snapshot); + let _ = changes_tx.send(changes); } tracing::info!("dispatcher task has terminated") }); @@ -219,8 +223,9 @@ impl Storage { // the task will stop when the sender is dropped. However, certain // test scenarios require us to wait that all resources are released. jh_dispatcher: Some(jh_dispatcher), - tx_dispatcher, - tx_state, + dispatcher_tx: tx_dispatcher, + snapshot_rx, + changes_rx, multistore_config, snapshots, db: shared_db, @@ -240,10 +245,20 @@ impl Storage { /// Returns a [`watch::Receiver`] that can be used to subscribe to new state versions. pub fn subscribe(&self) -> watch::Receiver { - // Calling subscribe() here to create a new receiver ensures - // that all previous values are marked as seen, and the user - // of the receiver will only be notified of *subsequent* values. - self.0.tx_state.subscribe() + let mut rx = self.0.snapshot_rx.clone(); + // Mark the current value as seen, so that the user of the receiver + // will only be notified of *subsequent* values. + rx.borrow_and_update(); + rx + } + + /// Returns a [`watch::Receiver`] that can be used to subscribe to state changes. + pub fn subscribe_changes(&self) -> watch::Receiver<(jmt::Version, Arc)> { + let mut rx = self.0.changes_rx.clone(); + // Mark the current value as seen, so that the user of the receiver + // will only be notified of *subsequent* values. + rx.borrow_and_update(); + rx } /// Returns a new [`Snapshot`] on top of the latest version of the tree. @@ -291,6 +306,9 @@ impl Storage { perform_migration: bool, ) -> Result { tracing::debug!(new_jmt_version = ?version, "committing state delta"); + // Save a copy of the changes to send to subscribers later. + let changes = Arc::new(cache.clone_changes()); + let mut changes_by_substore = cache.shard_by_prefix(&self.0.multistore_config); let mut substore_roots = Vec::new(); let mut multistore_versions = @@ -443,7 +461,10 @@ impl Storage { // Send fails if the channel is closed (i.e., if there are no receivers); // in this case, we should ignore the error, we have no one to notify. - let _ = self.0.tx_dispatcher.send(latest_snapshot); + let _ = self + .0 + .dispatcher_tx + .send((latest_snapshot, (version, changes))); Ok(global_root_hash) } diff --git a/crates/proto/src/gen/penumbra.cnidarium.v1alpha1.rs b/crates/proto/src/gen/penumbra.cnidarium.v1alpha1.rs index 6edd6f9cbc..33b0e9efef 100644 --- a/crates/proto/src/gen/penumbra.cnidarium.v1alpha1.rs +++ b/crates/proto/src/gen/penumbra.cnidarium.v1alpha1.rs @@ -91,6 +91,106 @@ impl ::prost::Name for PrefixValueResponse { ::prost::alloc::format!("penumbra.cnidarium.v1alpha1.{}", Self::NAME) } } +/// Requests a stream of new key-value pairs that have been committed to the state. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WatchRequest { + /// A regex for keys in the verifiable storage. + /// + /// Only key-value updates whose keys match this regex will be returned. + /// Note that the empty string matches all keys. + /// To exclude all keys, use the regex "$^", which matches no strings. + #[prost(string, tag = "1")] + pub key_regex: ::prost::alloc::string::String, + /// A regex for keys in the nonverifiable storage. + /// + /// Only key-value updates whose keys match this regex will be returned. + /// Note that the empty string matches all keys. + /// To exclude all keys, use the regex "$^", which matches no strings. + #[prost(string, tag = "2")] + pub nv_key_regex: ::prost::alloc::string::String, +} +impl ::prost::Name for WatchRequest { + const NAME: &'static str = "WatchRequest"; + const PACKAGE: &'static str = "penumbra.cnidarium.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("penumbra.cnidarium.v1alpha1.{}", Self::NAME) + } +} +/// A key-value pair that has been committed to the state. +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WatchResponse { + /// The state version the key-value pair was committed at. + #[prost(uint64, tag = "1")] + pub version: u64, + /// The entry that was committed. + #[prost(oneof = "watch_response::Entry", tags = "5, 6")] + pub entry: ::core::option::Option, +} +/// Nested message and enum types in `WatchResponse`. +pub mod watch_response { + /// Elements of the verifiable storage have string keys. + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Message)] + pub struct KeyValue { + #[prost(string, tag = "1")] + pub key: ::prost::alloc::string::String, + #[prost(bytes = "vec", tag = "2")] + pub value: ::prost::alloc::vec::Vec, + /// If set to true, the key-value pair was deleted. + /// This allows distinguishing a deleted key-value pair from a key-value pair whose value is empty. + #[prost(bool, tag = "3")] + pub deleted: bool, + } + impl ::prost::Name for KeyValue { + const NAME: &'static str = "KeyValue"; + const PACKAGE: &'static str = "penumbra.cnidarium.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!( + "penumbra.cnidarium.v1alpha1.WatchResponse.{}", Self::NAME + ) + } + } + /// Elements of the nonverifiable storage have byte keys. + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Message)] + pub struct NvKeyValue { + #[prost(bytes = "vec", tag = "1")] + pub key: ::prost::alloc::vec::Vec, + #[prost(bytes = "vec", tag = "2")] + pub value: ::prost::alloc::vec::Vec, + /// If set to true, the key-value pair was deleted. + /// This allows distinguishing a deleted key-value pair from a key-value pair whose value is empty. + #[prost(bool, tag = "3")] + pub deleted: bool, + } + impl ::prost::Name for NvKeyValue { + const NAME: &'static str = "NvKeyValue"; + const PACKAGE: &'static str = "penumbra.cnidarium.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!( + "penumbra.cnidarium.v1alpha1.WatchResponse.{}", Self::NAME + ) + } + } + /// The entry that was committed. + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Entry { + #[prost(message, tag = "5")] + Kv(KeyValue), + #[prost(message, tag = "6")] + NvKv(NvKeyValue), + } +} +impl ::prost::Name for WatchResponse { + const NAME: &'static str = "WatchResponse"; + const PACKAGE: &'static str = "penumbra.cnidarium.v1alpha1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!("penumbra.cnidarium.v1alpha1.{}", Self::NAME) + } +} /// Generated client implementations. #[cfg(feature = "rpc")] pub mod query_service_client { @@ -211,7 +311,6 @@ pub mod query_service_client { } /// General-purpose prefixed key-value state query API, that can be used to query /// arbitrary prefixes in the JMT storage. - /// Returns a stream of `PrefixValueResponse`s. pub async fn prefix_value( &mut self, request: impl tonic::IntoRequest, @@ -242,6 +341,34 @@ pub mod query_service_client { ); self.inner.server_streaming(req, path, codec).await } + /// Subscribes to a stream of key-value updates, with regex filtering on keys. + pub async fn watch( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response>, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::new( + tonic::Code::Unknown, + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/penumbra.cnidarium.v1alpha1.QueryService/Watch", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("penumbra.cnidarium.v1alpha1.QueryService", "Watch"), + ); + self.inner.server_streaming(req, path, codec).await + } } } /// Generated server implementations. @@ -269,7 +396,6 @@ pub mod query_service_server { + 'static; /// General-purpose prefixed key-value state query API, that can be used to query /// arbitrary prefixes in the JMT storage. - /// Returns a stream of `PrefixValueResponse`s. async fn prefix_value( &self, request: tonic::Request, @@ -277,6 +403,17 @@ pub mod query_service_server { tonic::Response, tonic::Status, >; + /// Server streaming response type for the Watch method. + type WatchStream: tonic::codegen::tokio_stream::Stream< + Item = std::result::Result, + > + + Send + + 'static; + /// Subscribes to a stream of key-value updates, with regex filtering on keys. + async fn watch( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; } #[derive(Debug)] pub struct QueryServiceServer { @@ -450,6 +587,53 @@ pub mod query_service_server { }; Box::pin(fut) } + "/penumbra.cnidarium.v1alpha1.QueryService/Watch" => { + #[allow(non_camel_case_types)] + struct WatchSvc(pub Arc); + impl< + T: QueryService, + > tonic::server::ServerStreamingService + for WatchSvc { + type Response = super::WatchResponse; + type ResponseStream = T::WatchStream; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::watch(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let inner = inner.0; + let method = WatchSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.server_streaming(method, req).await; + Ok(res) + }; + Box::pin(fut) + } _ => { Box::pin(async move { Ok( diff --git a/crates/proto/src/gen/penumbra.cnidarium.v1alpha1.serde.rs b/crates/proto/src/gen/penumbra.cnidarium.v1alpha1.serde.rs index b762affecd..c3fb51ff5b 100644 --- a/crates/proto/src/gen/penumbra.cnidarium.v1alpha1.serde.rs +++ b/crates/proto/src/gen/penumbra.cnidarium.v1alpha1.serde.rs @@ -546,3 +546,502 @@ impl<'de> serde::Deserialize<'de> for PrefixValueResponse { deserializer.deserialize_struct("penumbra.cnidarium.v1alpha1.PrefixValueResponse", FIELDS, GeneratedVisitor) } } +impl serde::Serialize for WatchRequest { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.key_regex.is_empty() { + len += 1; + } + if !self.nv_key_regex.is_empty() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("penumbra.cnidarium.v1alpha1.WatchRequest", len)?; + if !self.key_regex.is_empty() { + struct_ser.serialize_field("keyRegex", &self.key_regex)?; + } + if !self.nv_key_regex.is_empty() { + struct_ser.serialize_field("nvKeyRegex", &self.nv_key_regex)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WatchRequest { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "key_regex", + "keyRegex", + "nv_key_regex", + "nvKeyRegex", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + KeyRegex, + NvKeyRegex, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "keyRegex" | "key_regex" => Ok(GeneratedField::KeyRegex), + "nvKeyRegex" | "nv_key_regex" => Ok(GeneratedField::NvKeyRegex), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WatchRequest; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct penumbra.cnidarium.v1alpha1.WatchRequest") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut key_regex__ = None; + let mut nv_key_regex__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::KeyRegex => { + if key_regex__.is_some() { + return Err(serde::de::Error::duplicate_field("keyRegex")); + } + key_regex__ = Some(map_.next_value()?); + } + GeneratedField::NvKeyRegex => { + if nv_key_regex__.is_some() { + return Err(serde::de::Error::duplicate_field("nvKeyRegex")); + } + nv_key_regex__ = Some(map_.next_value()?); + } + } + } + Ok(WatchRequest { + key_regex: key_regex__.unwrap_or_default(), + nv_key_regex: nv_key_regex__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("penumbra.cnidarium.v1alpha1.WatchRequest", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for WatchResponse { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.version != 0 { + len += 1; + } + if self.entry.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("penumbra.cnidarium.v1alpha1.WatchResponse", len)?; + if self.version != 0 { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?; + } + if let Some(v) = self.entry.as_ref() { + match v { + watch_response::Entry::Kv(v) => { + struct_ser.serialize_field("kv", v)?; + } + watch_response::Entry::NvKv(v) => { + struct_ser.serialize_field("nvKv", v)?; + } + } + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for WatchResponse { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "version", + "kv", + "nv_kv", + "nvKv", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Version, + Kv, + NvKv, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "version" => Ok(GeneratedField::Version), + "kv" => Ok(GeneratedField::Kv), + "nvKv" | "nv_kv" => Ok(GeneratedField::NvKv), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = WatchResponse; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct penumbra.cnidarium.v1alpha1.WatchResponse") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut version__ = None; + let mut entry__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Version => { + if version__.is_some() { + return Err(serde::de::Error::duplicate_field("version")); + } + version__ = + Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) + ; + } + GeneratedField::Kv => { + if entry__.is_some() { + return Err(serde::de::Error::duplicate_field("kv")); + } + entry__ = map_.next_value::<::std::option::Option<_>>()?.map(watch_response::Entry::Kv) +; + } + GeneratedField::NvKv => { + if entry__.is_some() { + return Err(serde::de::Error::duplicate_field("nvKv")); + } + entry__ = map_.next_value::<::std::option::Option<_>>()?.map(watch_response::Entry::NvKv) +; + } + } + } + Ok(WatchResponse { + version: version__.unwrap_or_default(), + entry: entry__, + }) + } + } + deserializer.deserialize_struct("penumbra.cnidarium.v1alpha1.WatchResponse", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for watch_response::KeyValue { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.key.is_empty() { + len += 1; + } + if !self.value.is_empty() { + len += 1; + } + if self.deleted { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("penumbra.cnidarium.v1alpha1.WatchResponse.KeyValue", len)?; + if !self.key.is_empty() { + struct_ser.serialize_field("key", &self.key)?; + } + if !self.value.is_empty() { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?; + } + if self.deleted { + struct_ser.serialize_field("deleted", &self.deleted)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for watch_response::KeyValue { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "key", + "value", + "deleted", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Key, + Value, + Deleted, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "key" => Ok(GeneratedField::Key), + "value" => Ok(GeneratedField::Value), + "deleted" => Ok(GeneratedField::Deleted), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = watch_response::KeyValue; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct penumbra.cnidarium.v1alpha1.WatchResponse.KeyValue") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut key__ = None; + let mut value__ = None; + let mut deleted__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Key => { + if key__.is_some() { + return Err(serde::de::Error::duplicate_field("key")); + } + key__ = Some(map_.next_value()?); + } + GeneratedField::Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("value")); + } + value__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::Deleted => { + if deleted__.is_some() { + return Err(serde::de::Error::duplicate_field("deleted")); + } + deleted__ = Some(map_.next_value()?); + } + } + } + Ok(watch_response::KeyValue { + key: key__.unwrap_or_default(), + value: value__.unwrap_or_default(), + deleted: deleted__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("penumbra.cnidarium.v1alpha1.WatchResponse.KeyValue", FIELDS, GeneratedVisitor) + } +} +impl serde::Serialize for watch_response::NvKeyValue { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if !self.key.is_empty() { + len += 1; + } + if !self.value.is_empty() { + len += 1; + } + if self.deleted { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("penumbra.cnidarium.v1alpha1.WatchResponse.NvKeyValue", len)?; + if !self.key.is_empty() { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("key", pbjson::private::base64::encode(&self.key).as_str())?; + } + if !self.value.is_empty() { + #[allow(clippy::needless_borrow)] + struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?; + } + if self.deleted { + struct_ser.serialize_field("deleted", &self.deleted)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for watch_response::NvKeyValue { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "key", + "value", + "deleted", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Key, + Value, + Deleted, + } + impl<'de> serde::Deserialize<'de> for GeneratedField { + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + struct GeneratedVisitor; + + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = GeneratedField; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(formatter, "expected one of: {:?}", &FIELDS) + } + + #[allow(unused_variables)] + fn visit_str(self, value: &str) -> std::result::Result + where + E: serde::de::Error, + { + match value { + "key" => Ok(GeneratedField::Key), + "value" => Ok(GeneratedField::Value), + "deleted" => Ok(GeneratedField::Deleted), + _ => Err(serde::de::Error::unknown_field(value, FIELDS)), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = watch_response::NvKeyValue; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct penumbra.cnidarium.v1alpha1.WatchResponse.NvKeyValue") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut key__ = None; + let mut value__ = None; + let mut deleted__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Key => { + if key__.is_some() { + return Err(serde::de::Error::duplicate_field("key")); + } + key__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("value")); + } + value__ = + Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) + ; + } + GeneratedField::Deleted => { + if deleted__.is_some() { + return Err(serde::de::Error::duplicate_field("deleted")); + } + deleted__ = Some(map_.next_value()?); + } + } + } + Ok(watch_response::NvKeyValue { + key: key__.unwrap_or_default(), + value: value__.unwrap_or_default(), + deleted: deleted__.unwrap_or_default(), + }) + } + } + deserializer.deserialize_struct("penumbra.cnidarium.v1alpha1.WatchResponse.NvKeyValue", FIELDS, GeneratedVisitor) + } +} diff --git a/crates/proto/src/gen/proto_descriptor.bin.no_lfs b/crates/proto/src/gen/proto_descriptor.bin.no_lfs index 7cfebdc11c..44fc8f742c 100644 Binary files a/crates/proto/src/gen/proto_descriptor.bin.no_lfs and b/crates/proto/src/gen/proto_descriptor.bin.no_lfs differ diff --git a/proto/go/gen/penumbra/cnidarium/v1alpha1/cnidarium.pb.go b/proto/go/gen/penumbra/cnidarium/v1alpha1/cnidarium.pb.go index 71d63ba1a4..fdd647d160 100644 --- a/proto/go/gen/penumbra/cnidarium/v1alpha1/cnidarium.pb.go +++ b/proto/go/gen/penumbra/cnidarium/v1alpha1/cnidarium.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.31.0 +// protoc-gen-go v1.32.0 // protoc (unknown) // source: penumbra/cnidarium/v1alpha1/cnidarium.proto @@ -260,6 +260,165 @@ func (x *PrefixValueResponse) GetValue() []byte { return nil } +// Requests a stream of new key-value pairs that have been committed to the state. +type WatchRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // A regex for keys in the verifiable storage. + // + // Only key-value updates whose keys match this regex will be returned. + // Note that the empty string matches all keys. + // To exclude all keys, use the regex "$^", which matches no strings. + KeyRegex string `protobuf:"bytes,1,opt,name=key_regex,json=keyRegex,proto3" json:"key_regex,omitempty"` + // A regex for keys in the nonverifiable storage. + // + // Only key-value updates whose keys match this regex will be returned. + // Note that the empty string matches all keys. + // To exclude all keys, use the regex "$^", which matches no strings. + NvKeyRegex string `protobuf:"bytes,2,opt,name=nv_key_regex,json=nvKeyRegex,proto3" json:"nv_key_regex,omitempty"` +} + +func (x *WatchRequest) Reset() { + *x = WatchRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_penumbra_cnidarium_v1alpha1_cnidarium_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WatchRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WatchRequest) ProtoMessage() {} + +func (x *WatchRequest) ProtoReflect() protoreflect.Message { + mi := &file_penumbra_cnidarium_v1alpha1_cnidarium_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WatchRequest.ProtoReflect.Descriptor instead. +func (*WatchRequest) Descriptor() ([]byte, []int) { + return file_penumbra_cnidarium_v1alpha1_cnidarium_proto_rawDescGZIP(), []int{4} +} + +func (x *WatchRequest) GetKeyRegex() string { + if x != nil { + return x.KeyRegex + } + return "" +} + +func (x *WatchRequest) GetNvKeyRegex() string { + if x != nil { + return x.NvKeyRegex + } + return "" +} + +// A key-value pair that has been committed to the state. +type WatchResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // The state version the key-value pair was committed at. + Version uint64 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"` + // The entry that was committed. + // + // Types that are assignable to Entry: + // + // *WatchResponse_Kv + // *WatchResponse_NvKv + Entry isWatchResponse_Entry `protobuf_oneof:"entry"` +} + +func (x *WatchResponse) Reset() { + *x = WatchResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_penumbra_cnidarium_v1alpha1_cnidarium_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WatchResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WatchResponse) ProtoMessage() {} + +func (x *WatchResponse) ProtoReflect() protoreflect.Message { + mi := &file_penumbra_cnidarium_v1alpha1_cnidarium_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WatchResponse.ProtoReflect.Descriptor instead. +func (*WatchResponse) Descriptor() ([]byte, []int) { + return file_penumbra_cnidarium_v1alpha1_cnidarium_proto_rawDescGZIP(), []int{5} +} + +func (x *WatchResponse) GetVersion() uint64 { + if x != nil { + return x.Version + } + return 0 +} + +func (m *WatchResponse) GetEntry() isWatchResponse_Entry { + if m != nil { + return m.Entry + } + return nil +} + +func (x *WatchResponse) GetKv() *WatchResponse_KeyValue { + if x, ok := x.GetEntry().(*WatchResponse_Kv); ok { + return x.Kv + } + return nil +} + +func (x *WatchResponse) GetNvKv() *WatchResponse_NvKeyValue { + if x, ok := x.GetEntry().(*WatchResponse_NvKv); ok { + return x.NvKv + } + return nil +} + +type isWatchResponse_Entry interface { + isWatchResponse_Entry() +} + +type WatchResponse_Kv struct { + Kv *WatchResponse_KeyValue `protobuf:"bytes,5,opt,name=kv,proto3,oneof"` +} + +type WatchResponse_NvKv struct { + NvKv *WatchResponse_NvKeyValue `protobuf:"bytes,6,opt,name=nv_kv,json=nvKv,proto3,oneof"` +} + +func (*WatchResponse_Kv) isWatchResponse_Entry() {} + +func (*WatchResponse_NvKv) isWatchResponse_Entry() {} + type KeyValueResponse_Value struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -271,7 +430,7 @@ type KeyValueResponse_Value struct { func (x *KeyValueResponse_Value) Reset() { *x = KeyValueResponse_Value{} if protoimpl.UnsafeEnabled { - mi := &file_penumbra_cnidarium_v1alpha1_cnidarium_proto_msgTypes[4] + mi := &file_penumbra_cnidarium_v1alpha1_cnidarium_proto_msgTypes[6] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -284,7 +443,7 @@ func (x *KeyValueResponse_Value) String() string { func (*KeyValueResponse_Value) ProtoMessage() {} func (x *KeyValueResponse_Value) ProtoReflect() protoreflect.Message { - mi := &file_penumbra_cnidarium_v1alpha1_cnidarium_proto_msgTypes[4] + mi := &file_penumbra_cnidarium_v1alpha1_cnidarium_proto_msgTypes[6] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -307,6 +466,138 @@ func (x *KeyValueResponse_Value) GetValue() []byte { return nil } +// Elements of the verifiable storage have string keys. +type WatchResponse_KeyValue struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` + // If set to true, the key-value pair was deleted. + // This allows distinguishing a deleted key-value pair from a key-value pair whose value is empty. + Deleted bool `protobuf:"varint,3,opt,name=deleted,proto3" json:"deleted,omitempty"` +} + +func (x *WatchResponse_KeyValue) Reset() { + *x = WatchResponse_KeyValue{} + if protoimpl.UnsafeEnabled { + mi := &file_penumbra_cnidarium_v1alpha1_cnidarium_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WatchResponse_KeyValue) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WatchResponse_KeyValue) ProtoMessage() {} + +func (x *WatchResponse_KeyValue) ProtoReflect() protoreflect.Message { + mi := &file_penumbra_cnidarium_v1alpha1_cnidarium_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WatchResponse_KeyValue.ProtoReflect.Descriptor instead. +func (*WatchResponse_KeyValue) Descriptor() ([]byte, []int) { + return file_penumbra_cnidarium_v1alpha1_cnidarium_proto_rawDescGZIP(), []int{5, 0} +} + +func (x *WatchResponse_KeyValue) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *WatchResponse_KeyValue) GetValue() []byte { + if x != nil { + return x.Value + } + return nil +} + +func (x *WatchResponse_KeyValue) GetDeleted() bool { + if x != nil { + return x.Deleted + } + return false +} + +// Elements of the nonverifiable storage have byte keys. +type WatchResponse_NvKeyValue struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` + // If set to true, the key-value pair was deleted. + // This allows distinguishing a deleted key-value pair from a key-value pair whose value is empty. + Deleted bool `protobuf:"varint,3,opt,name=deleted,proto3" json:"deleted,omitempty"` +} + +func (x *WatchResponse_NvKeyValue) Reset() { + *x = WatchResponse_NvKeyValue{} + if protoimpl.UnsafeEnabled { + mi := &file_penumbra_cnidarium_v1alpha1_cnidarium_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *WatchResponse_NvKeyValue) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WatchResponse_NvKeyValue) ProtoMessage() {} + +func (x *WatchResponse_NvKeyValue) ProtoReflect() protoreflect.Message { + mi := &file_penumbra_cnidarium_v1alpha1_cnidarium_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WatchResponse_NvKeyValue.ProtoReflect.Descriptor instead. +func (*WatchResponse_NvKeyValue) Descriptor() ([]byte, []int) { + return file_penumbra_cnidarium_v1alpha1_cnidarium_proto_rawDescGZIP(), []int{5, 1} +} + +func (x *WatchResponse_NvKeyValue) GetKey() []byte { + if x != nil { + return x.Key + } + return nil +} + +func (x *WatchResponse_NvKeyValue) GetValue() []byte { + if x != nil { + return x.Value + } + return nil +} + +func (x *WatchResponse_NvKeyValue) GetDeleted() bool { + if x != nil { + return x.Deleted + } + return false +} + var File_penumbra_cnidarium_v1alpha1_cnidarium_proto protoreflect.FileDescriptor var file_penumbra_cnidarium_v1alpha1_cnidarium_proto_rawDesc = []byte{ @@ -342,41 +633,74 @@ var file_penumbra_cnidarium_v1alpha1_cnidarium_proto_rawDesc = []byte{ 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x32, 0xeb, 0x01, 0x0a, 0x0c, - 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x67, 0x0a, 0x08, - 0x4b, 0x65, 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x2c, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, - 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6e, 0x69, 0x64, 0x61, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x76, 0x31, - 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4b, 0x65, 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, - 0x61, 0x2e, 0x63, 0x6e, 0x69, 0x64, 0x61, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x76, 0x31, 0x61, 0x6c, - 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4b, 0x65, 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x72, 0x0a, 0x0b, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x56, - 0x61, 0x6c, 0x75, 0x65, 0x12, 0x2f, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, + 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x4d, 0x0a, 0x0c, 0x57, + 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x6b, + 0x65, 0x79, 0x5f, 0x72, 0x65, 0x67, 0x65, 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, + 0x6b, 0x65, 0x79, 0x52, 0x65, 0x67, 0x65, 0x78, 0x12, 0x20, 0x0a, 0x0c, 0x6e, 0x76, 0x5f, 0x6b, + 0x65, 0x79, 0x5f, 0x72, 0x65, 0x67, 0x65, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, + 0x6e, 0x76, 0x4b, 0x65, 0x79, 0x52, 0x65, 0x67, 0x65, 0x78, 0x22, 0xe5, 0x02, 0x0a, 0x0d, 0x57, + 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, + 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x76, + 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x45, 0x0a, 0x02, 0x6b, 0x76, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x33, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6e, + 0x69, 0x64, 0x61, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, + 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x4b, + 0x65, 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x02, 0x6b, 0x76, 0x12, 0x4c, 0x0a, + 0x05, 0x6e, 0x76, 0x5f, 0x6b, 0x76, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x70, + 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6e, 0x69, 0x64, 0x61, 0x72, 0x69, 0x75, + 0x6d, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x2e, 0x4e, 0x76, 0x4b, 0x65, 0x79, 0x56, 0x61, + 0x6c, 0x75, 0x65, 0x48, 0x00, 0x52, 0x04, 0x6e, 0x76, 0x4b, 0x76, 0x1a, 0x4c, 0x0a, 0x08, 0x4b, + 0x65, 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, + 0x18, 0x0a, 0x07, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x07, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x1a, 0x4e, 0x0a, 0x0a, 0x4e, 0x76, 0x4b, + 0x65, 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0c, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, + 0x18, 0x0a, 0x07, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x07, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x64, 0x42, 0x07, 0x0a, 0x05, 0x65, 0x6e, 0x74, + 0x72, 0x79, 0x32, 0xcd, 0x02, 0x0a, 0x0c, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x65, 0x72, 0x76, + 0x69, 0x63, 0x65, 0x12, 0x67, 0x0a, 0x08, 0x4b, 0x65, 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, + 0x2c, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6e, 0x69, 0x64, 0x61, + 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4b, 0x65, + 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d, 0x2e, + 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6e, 0x69, 0x64, 0x61, 0x72, 0x69, + 0x75, 0x6d, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4b, 0x65, 0x79, 0x56, + 0x61, 0x6c, 0x75, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x72, 0x0a, 0x0b, + 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x2f, 0x2e, 0x70, 0x65, + 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6e, 0x69, 0x64, 0x61, 0x72, 0x69, 0x75, 0x6d, + 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x30, 0x2e, 0x70, + 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6e, 0x69, 0x64, 0x61, 0x72, 0x69, 0x75, + 0x6d, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x50, 0x72, 0x65, 0x66, 0x69, + 0x78, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x30, 0x01, + 0x12, 0x60, 0x0a, 0x05, 0x57, 0x61, 0x74, 0x63, 0x68, 0x12, 0x29, 0x2e, 0x70, 0x65, 0x6e, 0x75, + 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6e, 0x69, 0x64, 0x61, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x76, + 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6e, 0x69, 0x64, 0x61, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, - 0x61, 0x31, 0x2e, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x30, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, - 0x2e, 0x63, 0x6e, 0x69, 0x64, 0x61, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, - 0x68, 0x61, 0x31, 0x2e, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x30, 0x01, 0x42, 0x9d, 0x02, 0x0a, 0x1f, 0x63, 0x6f, - 0x6d, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6e, 0x69, 0x64, 0x61, - 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x42, 0x0e, 0x43, - 0x6e, 0x69, 0x64, 0x61, 0x72, 0x69, 0x75, 0x6d, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, - 0x5c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x65, 0x6e, 0x75, - 0x6d, 0x62, 0x72, 0x61, 0x2d, 0x7a, 0x6f, 0x6e, 0x65, 0x2f, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, - 0x72, 0x61, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x2f, 0x67, 0x65, 0x6e, 0x2f, - 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2f, 0x63, 0x6e, 0x69, 0x64, 0x61, 0x72, 0x69, - 0x75, 0x6d, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x3b, 0x63, 0x6e, 0x69, 0x64, - 0x61, 0x72, 0x69, 0x75, 0x6d, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0xa2, 0x02, 0x03, - 0x50, 0x43, 0x58, 0xaa, 0x02, 0x1b, 0x50, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x43, - 0x6e, 0x69, 0x64, 0x61, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x56, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, - 0x31, 0xca, 0x02, 0x1b, 0x50, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x5c, 0x43, 0x6e, 0x69, - 0x64, 0x61, 0x72, 0x69, 0x75, 0x6d, 0x5c, 0x56, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0xe2, - 0x02, 0x27, 0x50, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x5c, 0x43, 0x6e, 0x69, 0x64, 0x61, - 0x72, 0x69, 0x75, 0x6d, 0x5c, 0x56, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x5c, 0x47, 0x50, - 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x1d, 0x50, 0x65, 0x6e, 0x75, - 0x6d, 0x62, 0x72, 0x61, 0x3a, 0x3a, 0x43, 0x6e, 0x69, 0x64, 0x61, 0x72, 0x69, 0x75, 0x6d, 0x3a, - 0x3a, 0x56, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x33, + 0x61, 0x31, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x30, 0x01, 0x42, 0x9d, 0x02, 0x0a, 0x1f, 0x63, 0x6f, 0x6d, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, + 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6e, 0x69, 0x64, 0x61, 0x72, 0x69, 0x75, 0x6d, 0x2e, 0x76, 0x31, + 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x42, 0x0e, 0x43, 0x6e, 0x69, 0x64, 0x61, 0x72, 0x69, 0x75, + 0x6d, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x5c, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, + 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2d, 0x7a, 0x6f, + 0x6e, 0x65, 0x2f, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2f, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2f, 0x67, 0x6f, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, + 0x61, 0x2f, 0x63, 0x6e, 0x69, 0x64, 0x61, 0x72, 0x69, 0x75, 0x6d, 0x2f, 0x76, 0x31, 0x61, 0x6c, + 0x70, 0x68, 0x61, 0x31, 0x3b, 0x63, 0x6e, 0x69, 0x64, 0x61, 0x72, 0x69, 0x75, 0x6d, 0x76, 0x31, + 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0xa2, 0x02, 0x03, 0x50, 0x43, 0x58, 0xaa, 0x02, 0x1b, 0x50, + 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x43, 0x6e, 0x69, 0x64, 0x61, 0x72, 0x69, 0x75, + 0x6d, 0x2e, 0x56, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0xca, 0x02, 0x1b, 0x50, 0x65, 0x6e, + 0x75, 0x6d, 0x62, 0x72, 0x61, 0x5c, 0x43, 0x6e, 0x69, 0x64, 0x61, 0x72, 0x69, 0x75, 0x6d, 0x5c, + 0x56, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0xe2, 0x02, 0x27, 0x50, 0x65, 0x6e, 0x75, 0x6d, + 0x62, 0x72, 0x61, 0x5c, 0x43, 0x6e, 0x69, 0x64, 0x61, 0x72, 0x69, 0x75, 0x6d, 0x5c, 0x56, 0x31, + 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, + 0x74, 0x61, 0xea, 0x02, 0x1d, 0x50, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x3a, 0x3a, 0x43, + 0x6e, 0x69, 0x64, 0x61, 0x72, 0x69, 0x75, 0x6d, 0x3a, 0x3a, 0x56, 0x31, 0x61, 0x6c, 0x70, 0x68, + 0x61, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( @@ -391,27 +715,35 @@ func file_penumbra_cnidarium_v1alpha1_cnidarium_proto_rawDescGZIP() []byte { return file_penumbra_cnidarium_v1alpha1_cnidarium_proto_rawDescData } -var file_penumbra_cnidarium_v1alpha1_cnidarium_proto_msgTypes = make([]protoimpl.MessageInfo, 5) +var file_penumbra_cnidarium_v1alpha1_cnidarium_proto_msgTypes = make([]protoimpl.MessageInfo, 9) var file_penumbra_cnidarium_v1alpha1_cnidarium_proto_goTypes = []interface{}{ - (*KeyValueRequest)(nil), // 0: penumbra.cnidarium.v1alpha1.KeyValueRequest - (*KeyValueResponse)(nil), // 1: penumbra.cnidarium.v1alpha1.KeyValueResponse - (*PrefixValueRequest)(nil), // 2: penumbra.cnidarium.v1alpha1.PrefixValueRequest - (*PrefixValueResponse)(nil), // 3: penumbra.cnidarium.v1alpha1.PrefixValueResponse - (*KeyValueResponse_Value)(nil), // 4: penumbra.cnidarium.v1alpha1.KeyValueResponse.Value - (*types.MerkleProof)(nil), // 5: ibc.core.commitment.v1.MerkleProof + (*KeyValueRequest)(nil), // 0: penumbra.cnidarium.v1alpha1.KeyValueRequest + (*KeyValueResponse)(nil), // 1: penumbra.cnidarium.v1alpha1.KeyValueResponse + (*PrefixValueRequest)(nil), // 2: penumbra.cnidarium.v1alpha1.PrefixValueRequest + (*PrefixValueResponse)(nil), // 3: penumbra.cnidarium.v1alpha1.PrefixValueResponse + (*WatchRequest)(nil), // 4: penumbra.cnidarium.v1alpha1.WatchRequest + (*WatchResponse)(nil), // 5: penumbra.cnidarium.v1alpha1.WatchResponse + (*KeyValueResponse_Value)(nil), // 6: penumbra.cnidarium.v1alpha1.KeyValueResponse.Value + (*WatchResponse_KeyValue)(nil), // 7: penumbra.cnidarium.v1alpha1.WatchResponse.KeyValue + (*WatchResponse_NvKeyValue)(nil), // 8: penumbra.cnidarium.v1alpha1.WatchResponse.NvKeyValue + (*types.MerkleProof)(nil), // 9: ibc.core.commitment.v1.MerkleProof } var file_penumbra_cnidarium_v1alpha1_cnidarium_proto_depIdxs = []int32{ - 4, // 0: penumbra.cnidarium.v1alpha1.KeyValueResponse.value:type_name -> penumbra.cnidarium.v1alpha1.KeyValueResponse.Value - 5, // 1: penumbra.cnidarium.v1alpha1.KeyValueResponse.proof:type_name -> ibc.core.commitment.v1.MerkleProof - 0, // 2: penumbra.cnidarium.v1alpha1.QueryService.KeyValue:input_type -> penumbra.cnidarium.v1alpha1.KeyValueRequest - 2, // 3: penumbra.cnidarium.v1alpha1.QueryService.PrefixValue:input_type -> penumbra.cnidarium.v1alpha1.PrefixValueRequest - 1, // 4: penumbra.cnidarium.v1alpha1.QueryService.KeyValue:output_type -> penumbra.cnidarium.v1alpha1.KeyValueResponse - 3, // 5: penumbra.cnidarium.v1alpha1.QueryService.PrefixValue:output_type -> penumbra.cnidarium.v1alpha1.PrefixValueResponse - 4, // [4:6] is the sub-list for method output_type - 2, // [2:4] is the sub-list for method input_type - 2, // [2:2] is the sub-list for extension type_name - 2, // [2:2] is the sub-list for extension extendee - 0, // [0:2] is the sub-list for field type_name + 6, // 0: penumbra.cnidarium.v1alpha1.KeyValueResponse.value:type_name -> penumbra.cnidarium.v1alpha1.KeyValueResponse.Value + 9, // 1: penumbra.cnidarium.v1alpha1.KeyValueResponse.proof:type_name -> ibc.core.commitment.v1.MerkleProof + 7, // 2: penumbra.cnidarium.v1alpha1.WatchResponse.kv:type_name -> penumbra.cnidarium.v1alpha1.WatchResponse.KeyValue + 8, // 3: penumbra.cnidarium.v1alpha1.WatchResponse.nv_kv:type_name -> penumbra.cnidarium.v1alpha1.WatchResponse.NvKeyValue + 0, // 4: penumbra.cnidarium.v1alpha1.QueryService.KeyValue:input_type -> penumbra.cnidarium.v1alpha1.KeyValueRequest + 2, // 5: penumbra.cnidarium.v1alpha1.QueryService.PrefixValue:input_type -> penumbra.cnidarium.v1alpha1.PrefixValueRequest + 4, // 6: penumbra.cnidarium.v1alpha1.QueryService.Watch:input_type -> penumbra.cnidarium.v1alpha1.WatchRequest + 1, // 7: penumbra.cnidarium.v1alpha1.QueryService.KeyValue:output_type -> penumbra.cnidarium.v1alpha1.KeyValueResponse + 3, // 8: penumbra.cnidarium.v1alpha1.QueryService.PrefixValue:output_type -> penumbra.cnidarium.v1alpha1.PrefixValueResponse + 5, // 9: penumbra.cnidarium.v1alpha1.QueryService.Watch:output_type -> penumbra.cnidarium.v1alpha1.WatchResponse + 7, // [7:10] is the sub-list for method output_type + 4, // [4:7] is the sub-list for method input_type + 4, // [4:4] is the sub-list for extension type_name + 4, // [4:4] is the sub-list for extension extendee + 0, // [0:4] is the sub-list for field type_name } func init() { file_penumbra_cnidarium_v1alpha1_cnidarium_proto_init() } @@ -469,6 +801,30 @@ func file_penumbra_cnidarium_v1alpha1_cnidarium_proto_init() { } } file_penumbra_cnidarium_v1alpha1_cnidarium_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WatchRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_penumbra_cnidarium_v1alpha1_cnidarium_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WatchResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_penumbra_cnidarium_v1alpha1_cnidarium_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*KeyValueResponse_Value); i { case 0: return &v.state @@ -480,6 +836,34 @@ func file_penumbra_cnidarium_v1alpha1_cnidarium_proto_init() { return nil } } + file_penumbra_cnidarium_v1alpha1_cnidarium_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WatchResponse_KeyValue); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_penumbra_cnidarium_v1alpha1_cnidarium_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*WatchResponse_NvKeyValue); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_penumbra_cnidarium_v1alpha1_cnidarium_proto_msgTypes[5].OneofWrappers = []interface{}{ + (*WatchResponse_Kv)(nil), + (*WatchResponse_NvKv)(nil), } type x struct{} out := protoimpl.TypeBuilder{ @@ -487,7 +871,7 @@ func file_penumbra_cnidarium_v1alpha1_cnidarium_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_penumbra_cnidarium_v1alpha1_cnidarium_proto_rawDesc, NumEnums: 0, - NumMessages: 5, + NumMessages: 9, NumExtensions: 0, NumServices: 1, }, diff --git a/proto/go/gen/penumbra/core/app/v1alpha1/app.pb.go b/proto/go/gen/penumbra/core/app/v1alpha1/app.pb.go index b51947e985..ff135d7606 100644 --- a/proto/go/gen/penumbra/core/app/v1alpha1/app.pb.go +++ b/proto/go/gen/penumbra/core/app/v1alpha1/app.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.31.0 +// protoc-gen-go v1.32.0 // protoc (unknown) // source: penumbra/core/app/v1alpha1/app.proto diff --git a/proto/go/gen/penumbra/core/asset/v1alpha1/asset.pb.go b/proto/go/gen/penumbra/core/asset/v1alpha1/asset.pb.go index f42fa117c8..2c8407e352 100644 --- a/proto/go/gen/penumbra/core/asset/v1alpha1/asset.pb.go +++ b/proto/go/gen/penumbra/core/asset/v1alpha1/asset.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.31.0 +// protoc-gen-go v1.32.0 // protoc (unknown) // source: penumbra/core/asset/v1alpha1/asset.proto diff --git a/proto/go/gen/penumbra/core/component/chain/v1alpha1/chain.pb.go b/proto/go/gen/penumbra/core/component/chain/v1alpha1/chain.pb.go index 5e7e80954d..885a003812 100644 --- a/proto/go/gen/penumbra/core/component/chain/v1alpha1/chain.pb.go +++ b/proto/go/gen/penumbra/core/component/chain/v1alpha1/chain.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.31.0 +// protoc-gen-go v1.32.0 // protoc (unknown) // source: penumbra/core/component/chain/v1alpha1/chain.proto diff --git a/proto/go/gen/penumbra/core/component/compact_block/v1alpha1/compact_block.pb.go b/proto/go/gen/penumbra/core/component/compact_block/v1alpha1/compact_block.pb.go index 986f115279..f10f73e391 100644 --- a/proto/go/gen/penumbra/core/component/compact_block/v1alpha1/compact_block.pb.go +++ b/proto/go/gen/penumbra/core/component/compact_block/v1alpha1/compact_block.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.31.0 +// protoc-gen-go v1.32.0 // protoc (unknown) // source: penumbra/core/component/compact_block/v1alpha1/compact_block.proto @@ -12,7 +12,6 @@ import ( v1alpha14 "github.com/penumbra-zone/penumbra/proto/go/gen/penumbra/core/component/fee/v1alpha1" v1alpha1 "github.com/penumbra-zone/penumbra/proto/go/gen/penumbra/core/component/sct/v1alpha1" v1alpha15 "github.com/penumbra-zone/penumbra/proto/go/gen/penumbra/core/component/shielded_pool/v1alpha1" - _ "github.com/penumbra-zone/penumbra/proto/go/gen/penumbra/core/transaction/v1alpha1" v1alpha11 "github.com/penumbra-zone/penumbra/proto/go/gen/penumbra/crypto/tct/v1alpha1" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" @@ -557,152 +556,149 @@ var file_penumbra_core_component_compact_block_v1alpha1_compact_block_proto_rawD 0x64, 0x5f, 0x70, 0x6f, 0x6f, 0x6c, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x26, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2f, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2f, 0x74, 0x63, 0x74, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x74, 0x63, 0x74, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x34, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2f, 0x63, - 0x6f, 0x72, 0x65, 0x2f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2f, - 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, - 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xdb, 0x05, 0x0a, 0x0c, 0x43, - 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x12, 0x16, 0x0a, 0x06, 0x68, - 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x68, 0x65, 0x69, - 0x67, 0x68, 0x74, 0x12, 0x63, 0x0a, 0x0e, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x70, 0x61, 0x79, - 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3c, 0x2e, 0x70, 0x65, - 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x70, - 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x5f, 0x62, 0x6c, - 0x6f, 0x63, 0x6b, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53, 0x74, 0x61, - 0x74, 0x65, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x52, 0x0d, 0x73, 0x74, 0x61, 0x74, 0x65, - 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x12, 0x4f, 0x0a, 0x0a, 0x6e, 0x75, 0x6c, 0x6c, - 0x69, 0x66, 0x69, 0x65, 0x72, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x70, - 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, - 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x73, 0x63, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, - 0x68, 0x61, 0x31, 0x2e, 0x4e, 0x75, 0x6c, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x0a, 0x6e, - 0x75, 0x6c, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x73, 0x12, 0x47, 0x0a, 0x0a, 0x62, 0x6c, 0x6f, - 0x63, 0x6b, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, - 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2e, - 0x74, 0x63, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4d, 0x65, 0x72, - 0x6b, 0x6c, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x09, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x6f, - 0x6f, 0x74, 0x12, 0x47, 0x0a, 0x0a, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x72, 0x6f, 0x6f, 0x74, - 0x18, 0x11, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, - 0x61, 0x2e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2e, 0x74, 0x63, 0x74, 0x2e, 0x76, 0x31, 0x61, - 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x52, 0x6f, 0x6f, 0x74, - 0x52, 0x09, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x29, 0x0a, 0x10, 0x70, - 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x65, 0x64, 0x18, - 0x14, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x53, - 0x74, 0x61, 0x72, 0x74, 0x65, 0x64, 0x12, 0x5c, 0x0a, 0x0e, 0x66, 0x6d, 0x64, 0x5f, 0x70, 0x61, - 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x18, 0x64, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x35, - 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, - 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x2e, 0x76, - 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x46, 0x6d, 0x64, 0x50, 0x61, 0x72, 0x61, 0x6d, - 0x65, 0x74, 0x65, 0x72, 0x73, 0x52, 0x0d, 0x66, 0x6d, 0x64, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, - 0x74, 0x65, 0x72, 0x73, 0x12, 0x5c, 0x0a, 0x0c, 0x73, 0x77, 0x61, 0x70, 0x5f, 0x6f, 0x75, 0x74, - 0x70, 0x75, 0x74, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x39, 0x2e, 0x70, 0x65, 0x6e, - 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, - 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x64, 0x65, 0x78, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, - 0x31, 0x2e, 0x42, 0x61, 0x74, 0x63, 0x68, 0x53, 0x77, 0x61, 0x70, 0x4f, 0x75, 0x74, 0x70, 0x75, - 0x74, 0x44, 0x61, 0x74, 0x61, 0x52, 0x0b, 0x73, 0x77, 0x61, 0x70, 0x4f, 0x75, 0x74, 0x70, 0x75, - 0x74, 0x73, 0x12, 0x34, 0x0a, 0x16, 0x61, 0x70, 0x70, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, - 0x74, 0x65, 0x72, 0x73, 0x5f, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x18, 0x06, 0x20, 0x01, - 0x28, 0x08, 0x52, 0x14, 0x61, 0x70, 0x70, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, - 0x73, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x12, 0x4e, 0x0a, 0x0a, 0x67, 0x61, 0x73, 0x5f, - 0x70, 0x72, 0x69, 0x63, 0x65, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x70, - 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, - 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x66, 0x65, 0x65, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, - 0x68, 0x61, 0x31, 0x2e, 0x47, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x73, 0x52, 0x09, 0x67, - 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x73, 0x22, 0x8a, 0x05, 0x0a, 0x0c, 0x53, 0x74, 0x61, - 0x74, 0x65, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x12, 0x4e, 0x0a, 0x06, 0x73, 0x6f, 0x75, - 0x72, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x70, 0x65, 0x6e, 0x75, - 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, - 0x65, 0x6e, 0x74, 0x2e, 0x73, 0x63, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, - 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x6f, 0x75, 0x72, 0x63, - 0x65, 0x52, 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x64, 0x0a, 0x09, 0x72, 0x6f, 0x6c, - 0x6c, 0x65, 0x64, 0x5f, 0x75, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x45, 0x2e, 0x70, - 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, - 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x5f, 0x62, - 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53, 0x74, - 0x61, 0x74, 0x65, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x52, 0x6f, 0x6c, 0x6c, 0x65, - 0x64, 0x55, 0x70, 0x48, 0x00, 0x52, 0x08, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x64, 0x55, 0x70, 0x12, - 0x57, 0x0a, 0x04, 0x6e, 0x6f, 0x74, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x41, 0x2e, - 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, - 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x5f, - 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53, - 0x74, 0x61, 0x74, 0x65, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x4e, 0x6f, 0x74, 0x65, - 0x48, 0x00, 0x52, 0x04, 0x6e, 0x6f, 0x74, 0x65, 0x12, 0x57, 0x0a, 0x04, 0x73, 0x77, 0x61, 0x70, - 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x41, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, + 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xdb, 0x05, 0x0a, 0x0c, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, + 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x12, 0x16, 0x0a, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x63, 0x0a, + 0x0e, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x18, + 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3c, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, + 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, + 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x76, 0x31, + 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x50, 0x61, 0x79, 0x6c, + 0x6f, 0x61, 0x64, 0x52, 0x0d, 0x73, 0x74, 0x61, 0x74, 0x65, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, + 0x64, 0x73, 0x12, 0x4f, 0x0a, 0x0a, 0x6e, 0x75, 0x6c, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x73, + 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, + 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, + 0x2e, 0x73, 0x63, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4e, 0x75, + 0x6c, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x52, 0x0a, 0x6e, 0x75, 0x6c, 0x6c, 0x69, 0x66, 0x69, + 0x65, 0x72, 0x73, 0x12, 0x47, 0x0a, 0x0a, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x5f, 0x72, 0x6f, 0x6f, + 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, + 0x72, 0x61, 0x2e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2e, 0x74, 0x63, 0x74, 0x2e, 0x76, 0x31, + 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x52, 0x6f, 0x6f, + 0x74, 0x52, 0x09, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x47, 0x0a, 0x0a, + 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x28, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x72, 0x79, 0x70, + 0x74, 0x6f, 0x2e, 0x74, 0x63, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, + 0x4d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x09, 0x65, 0x70, 0x6f, 0x63, + 0x68, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x29, 0x0a, 0x10, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, + 0x6c, 0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x65, 0x64, 0x18, 0x14, 0x20, 0x01, 0x28, 0x08, 0x52, + 0x0f, 0x70, 0x72, 0x6f, 0x70, 0x6f, 0x73, 0x61, 0x6c, 0x53, 0x74, 0x61, 0x72, 0x74, 0x65, 0x64, + 0x12, 0x5c, 0x0a, 0x0e, 0x66, 0x6d, 0x64, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, + 0x72, 0x73, 0x18, 0x64, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, + 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, + 0x6e, 0x74, 0x2e, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, + 0x31, 0x2e, 0x46, 0x6d, 0x64, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x52, + 0x0d, 0x66, 0x6d, 0x64, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x12, 0x5c, + 0x0a, 0x0c, 0x73, 0x77, 0x61, 0x70, 0x5f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x18, 0x05, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x39, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x64, + 0x65, 0x78, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x42, 0x61, 0x74, 0x63, + 0x68, 0x53, 0x77, 0x61, 0x70, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x44, 0x61, 0x74, 0x61, 0x52, + 0x0b, 0x73, 0x77, 0x61, 0x70, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x73, 0x12, 0x34, 0x0a, 0x16, + 0x61, 0x70, 0x70, 0x5f, 0x70, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x5f, 0x75, + 0x70, 0x64, 0x61, 0x74, 0x65, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x14, 0x61, 0x70, + 0x70, 0x50, 0x61, 0x72, 0x61, 0x6d, 0x65, 0x74, 0x65, 0x72, 0x73, 0x55, 0x70, 0x64, 0x61, 0x74, + 0x65, 0x64, 0x12, 0x4e, 0x0a, 0x0a, 0x67, 0x61, 0x73, 0x5f, 0x70, 0x72, 0x69, 0x63, 0x65, 0x73, + 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, + 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, + 0x2e, 0x66, 0x65, 0x65, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x47, 0x61, + 0x73, 0x50, 0x72, 0x69, 0x63, 0x65, 0x73, 0x52, 0x09, 0x67, 0x61, 0x73, 0x50, 0x72, 0x69, 0x63, + 0x65, 0x73, 0x22, 0x8a, 0x05, 0x0a, 0x0c, 0x53, 0x74, 0x61, 0x74, 0x65, 0x50, 0x61, 0x79, 0x6c, + 0x6f, 0x61, 0x64, 0x12, 0x4e, 0x0a, 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, + 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x73, 0x63, + 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, + 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, 0x06, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x12, 0x64, 0x0a, 0x09, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x64, 0x5f, 0x75, 0x70, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x45, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x50, 0x61, 0x79, - 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x53, 0x77, 0x61, 0x70, 0x48, 0x00, 0x52, 0x04, 0x73, 0x77, 0x61, - 0x70, 0x1a, 0x59, 0x0a, 0x08, 0x52, 0x6f, 0x6c, 0x6c, 0x65, 0x64, 0x55, 0x70, 0x12, 0x4d, 0x0a, - 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x2d, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x72, 0x79, - 0x70, 0x74, 0x6f, 0x2e, 0x74, 0x63, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, - 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, - 0x52, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x1a, 0x57, 0x0a, 0x04, - 0x4e, 0x6f, 0x74, 0x65, 0x12, 0x4f, 0x0a, 0x04, 0x6e, 0x6f, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x3b, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, - 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x73, 0x68, 0x69, - 0x65, 0x6c, 0x64, 0x65, 0x64, 0x5f, 0x70, 0x6f, 0x6f, 0x6c, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, - 0x68, 0x61, 0x31, 0x2e, 0x4e, 0x6f, 0x74, 0x65, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x52, - 0x04, 0x6e, 0x6f, 0x74, 0x65, 0x1a, 0x4d, 0x0a, 0x04, 0x53, 0x77, 0x61, 0x70, 0x12, 0x45, 0x0a, - 0x04, 0x73, 0x77, 0x61, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x70, 0x65, - 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x70, - 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x64, 0x65, 0x78, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, - 0x61, 0x31, 0x2e, 0x53, 0x77, 0x61, 0x70, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x52, 0x04, - 0x73, 0x77, 0x61, 0x70, 0x42, 0x0f, 0x0a, 0x0d, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x70, 0x61, - 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, 0x96, 0x01, 0x0a, 0x18, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x63, - 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x12, 0x19, 0x0a, 0x08, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x12, 0x21, 0x0a, - 0x0c, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x04, 0x52, 0x0b, 0x73, 0x74, 0x61, 0x72, 0x74, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, - 0x12, 0x1d, 0x0a, 0x0a, 0x65, 0x6e, 0x64, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x65, 0x6e, 0x64, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, - 0x1d, 0x0a, 0x0a, 0x6b, 0x65, 0x65, 0x70, 0x5f, 0x61, 0x6c, 0x69, 0x76, 0x65, 0x18, 0x04, 0x20, - 0x01, 0x28, 0x08, 0x52, 0x09, 0x6b, 0x65, 0x65, 0x70, 0x41, 0x6c, 0x69, 0x76, 0x65, 0x22, 0x7e, - 0x0a, 0x19, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x61, - 0x6e, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x61, 0x0a, 0x0d, 0x63, - 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x3c, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, - 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x63, 0x6f, 0x6d, - 0x70, 0x61, 0x63, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, - 0x68, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, - 0x52, 0x0c, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x32, 0xbb, - 0x01, 0x0a, 0x0c, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, - 0xaa, 0x01, 0x0a, 0x11, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, - 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x48, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, + 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x52, 0x6f, 0x6c, 0x6c, 0x65, 0x64, 0x55, 0x70, 0x48, 0x00, 0x52, + 0x08, 0x72, 0x6f, 0x6c, 0x6c, 0x65, 0x64, 0x55, 0x70, 0x12, 0x57, 0x0a, 0x04, 0x6e, 0x6f, 0x74, + 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x41, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, + 0x72, 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, + 0x74, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2e, + 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x50, 0x61, + 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x4e, 0x6f, 0x74, 0x65, 0x48, 0x00, 0x52, 0x04, 0x6e, 0x6f, + 0x74, 0x65, 0x12, 0x57, 0x0a, 0x04, 0x73, 0x77, 0x61, 0x70, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x41, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, + 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x61, + 0x63, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, + 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2e, 0x53, + 0x77, 0x61, 0x70, 0x48, 0x00, 0x52, 0x04, 0x73, 0x77, 0x61, 0x70, 0x1a, 0x59, 0x0a, 0x08, 0x52, + 0x6f, 0x6c, 0x6c, 0x65, 0x64, 0x55, 0x70, 0x12, 0x4d, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x69, + 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x70, 0x65, + 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2e, 0x74, 0x63, + 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, + 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, + 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x1a, 0x57, 0x0a, 0x04, 0x4e, 0x6f, 0x74, 0x65, 0x12, 0x4f, + 0x0a, 0x04, 0x6e, 0x6f, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x3b, 0x2e, 0x70, + 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, + 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x73, 0x68, 0x69, 0x65, 0x6c, 0x64, 0x65, 0x64, 0x5f, + 0x70, 0x6f, 0x6f, 0x6c, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4e, 0x6f, + 0x74, 0x65, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x52, 0x04, 0x6e, 0x6f, 0x74, 0x65, 0x1a, + 0x4d, 0x0a, 0x04, 0x53, 0x77, 0x61, 0x70, 0x12, 0x45, 0x0a, 0x04, 0x73, 0x77, 0x61, 0x70, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, - 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x76, 0x31, - 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x42, 0x6c, - 0x6f, 0x63, 0x6b, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x49, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, + 0x64, 0x65, 0x78, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x53, 0x77, 0x61, + 0x70, 0x50, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x52, 0x04, 0x73, 0x77, 0x61, 0x70, 0x42, 0x0f, + 0x0a, 0x0d, 0x73, 0x74, 0x61, 0x74, 0x65, 0x5f, 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x22, + 0x96, 0x01, 0x0a, 0x18, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, + 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x19, 0x0a, 0x08, + 0x63, 0x68, 0x61, 0x69, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, + 0x63, 0x68, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x73, + 0x74, 0x61, 0x72, 0x74, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x65, 0x6e, + 0x64, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, + 0x65, 0x6e, 0x64, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x6b, 0x65, 0x65, + 0x70, 0x5f, 0x61, 0x6c, 0x69, 0x76, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x6b, + 0x65, 0x65, 0x70, 0x41, 0x6c, 0x69, 0x76, 0x65, 0x22, 0x7e, 0x0a, 0x19, 0x43, 0x6f, 0x6d, 0x70, + 0x61, 0x63, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x61, 0x0a, 0x0d, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, + 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x3c, 0x2e, 0x70, + 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, + 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x5f, 0x62, + 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, 0x6f, + 0x6d, 0x70, 0x61, 0x63, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x0c, 0x63, 0x6f, 0x6d, 0x70, + 0x61, 0x63, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x32, 0xbb, 0x01, 0x0a, 0x0c, 0x51, 0x75, 0x65, + 0x72, 0x79, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0xaa, 0x01, 0x0a, 0x11, 0x43, 0x6f, + 0x6d, 0x70, 0x61, 0x63, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, + 0x48, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x61, 0x6e, - 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x30, 0x01, 0x42, 0x95, 0x03, 0x0a, - 0x32, 0x63, 0x6f, 0x6d, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, - 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x63, 0x6f, 0x6d, - 0x70, 0x61, 0x63, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, - 0x68, 0x61, 0x31, 0x42, 0x11, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x42, 0x6c, 0x6f, 0x63, - 0x6b, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x73, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, - 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2d, 0x7a, 0x6f, - 0x6e, 0x65, 0x2f, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2f, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2f, 0x67, 0x6f, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, - 0x61, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, - 0x2f, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2f, 0x76, - 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x3b, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x5f, - 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0xa2, 0x02, 0x04, - 0x50, 0x43, 0x43, 0x43, 0xaa, 0x02, 0x2d, 0x50, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, - 0x43, 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x43, - 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x56, 0x31, 0x61, 0x6c, - 0x70, 0x68, 0x61, 0x31, 0xca, 0x02, 0x2d, 0x50, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x5c, - 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x5c, 0x43, - 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x5c, 0x56, 0x31, 0x61, 0x6c, - 0x70, 0x68, 0x61, 0x31, 0xe2, 0x02, 0x39, 0x50, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x5c, - 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x5c, 0x43, - 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x5c, 0x56, 0x31, 0x61, 0x6c, - 0x70, 0x68, 0x61, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, - 0xea, 0x02, 0x31, 0x50, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x3a, 0x3a, 0x43, 0x6f, 0x72, - 0x65, 0x3a, 0x3a, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x3a, 0x3a, 0x43, 0x6f, - 0x6d, 0x70, 0x61, 0x63, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x3a, 0x3a, 0x56, 0x31, 0x61, 0x6c, - 0x70, 0x68, 0x61, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x49, 0x2e, 0x70, 0x65, 0x6e, 0x75, + 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, + 0x65, 0x6e, 0x74, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, + 0x6b, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x6d, 0x70, 0x61, + 0x63, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x30, 0x01, 0x42, 0x95, 0x03, 0x0a, 0x32, 0x63, 0x6f, 0x6d, 0x2e, 0x70, + 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, + 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x5f, 0x62, + 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x42, 0x11, 0x43, + 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x50, 0x72, 0x6f, 0x74, 0x6f, + 0x50, 0x01, 0x5a, 0x73, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, + 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2d, 0x7a, 0x6f, 0x6e, 0x65, 0x2f, 0x70, 0x65, 0x6e, + 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x2f, 0x67, + 0x65, 0x6e, 0x2f, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2f, 0x63, 0x6f, 0x72, 0x65, + 0x2f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2f, 0x63, 0x6f, 0x6d, 0x70, 0x61, + 0x63, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, + 0x31, 0x3b, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x5f, 0x62, 0x6c, 0x6f, 0x63, 0x6b, 0x76, + 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0xa2, 0x02, 0x04, 0x50, 0x43, 0x43, 0x43, 0xaa, 0x02, + 0x2d, 0x50, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x43, 0x6f, 0x72, 0x65, 0x2e, 0x43, + 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, + 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x2e, 0x56, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0xca, 0x02, + 0x2d, 0x50, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x43, + 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x5c, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, + 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x5c, 0x56, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0xe2, 0x02, + 0x39, 0x50, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x43, + 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x5c, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, + 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x5c, 0x56, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x5c, 0x47, + 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x31, 0x50, 0x65, 0x6e, + 0x75, 0x6d, 0x62, 0x72, 0x61, 0x3a, 0x3a, 0x43, 0x6f, 0x72, 0x65, 0x3a, 0x3a, 0x43, 0x6f, 0x6d, + 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x3a, 0x3a, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x42, + 0x6c, 0x6f, 0x63, 0x6b, 0x3a, 0x3a, 0x56, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x62, 0x06, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( diff --git a/proto/go/gen/penumbra/core/component/dao/v1alpha1/dao.pb.go b/proto/go/gen/penumbra/core/component/dao/v1alpha1/dao.pb.go index 95b04ba89b..bc58764418 100644 --- a/proto/go/gen/penumbra/core/component/dao/v1alpha1/dao.pb.go +++ b/proto/go/gen/penumbra/core/component/dao/v1alpha1/dao.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.31.0 +// protoc-gen-go v1.32.0 // protoc (unknown) // source: penumbra/core/component/dao/v1alpha1/dao.proto diff --git a/proto/go/gen/penumbra/core/component/dex/v1alpha1/dex.pb.go b/proto/go/gen/penumbra/core/component/dex/v1alpha1/dex.pb.go index 301036bbcb..f8d2e0c20d 100644 --- a/proto/go/gen/penumbra/core/component/dex/v1alpha1/dex.pb.go +++ b/proto/go/gen/penumbra/core/component/dex/v1alpha1/dex.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.31.0 +// protoc-gen-go v1.32.0 // protoc (unknown) // source: penumbra/core/component/dex/v1alpha1/dex.proto diff --git a/proto/go/gen/penumbra/core/component/distributions/v1alpha1/distributions.pb.go b/proto/go/gen/penumbra/core/component/distributions/v1alpha1/distributions.pb.go index 07dac232c5..a3a8170413 100644 --- a/proto/go/gen/penumbra/core/component/distributions/v1alpha1/distributions.pb.go +++ b/proto/go/gen/penumbra/core/component/distributions/v1alpha1/distributions.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.31.0 +// protoc-gen-go v1.32.0 // protoc (unknown) // source: penumbra/core/component/distributions/v1alpha1/distributions.proto diff --git a/proto/go/gen/penumbra/core/component/fee/v1alpha1/fee.pb.go b/proto/go/gen/penumbra/core/component/fee/v1alpha1/fee.pb.go index 9e86de8b13..54a03a6eff 100644 --- a/proto/go/gen/penumbra/core/component/fee/v1alpha1/fee.pb.go +++ b/proto/go/gen/penumbra/core/component/fee/v1alpha1/fee.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.31.0 +// protoc-gen-go v1.32.0 // protoc (unknown) // source: penumbra/core/component/fee/v1alpha1/fee.proto diff --git a/proto/go/gen/penumbra/core/component/governance/v1alpha1/governance.pb.go b/proto/go/gen/penumbra/core/component/governance/v1alpha1/governance.pb.go index 69048709f1..114ca3defb 100644 --- a/proto/go/gen/penumbra/core/component/governance/v1alpha1/governance.pb.go +++ b/proto/go/gen/penumbra/core/component/governance/v1alpha1/governance.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.31.0 +// protoc-gen-go v1.32.0 // protoc (unknown) // source: penumbra/core/component/governance/v1alpha1/governance.proto diff --git a/proto/go/gen/penumbra/core/component/ibc/v1alpha1/ibc.pb.go b/proto/go/gen/penumbra/core/component/ibc/v1alpha1/ibc.pb.go index 1db4e7464f..3f01c9da27 100644 --- a/proto/go/gen/penumbra/core/component/ibc/v1alpha1/ibc.pb.go +++ b/proto/go/gen/penumbra/core/component/ibc/v1alpha1/ibc.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.31.0 +// protoc-gen-go v1.32.0 // protoc (unknown) // source: penumbra/core/component/ibc/v1alpha1/ibc.proto diff --git a/proto/go/gen/penumbra/core/component/sct/v1alpha1/sct.pb.go b/proto/go/gen/penumbra/core/component/sct/v1alpha1/sct.pb.go index fceeb21fcd..dc2b10a5aa 100644 --- a/proto/go/gen/penumbra/core/component/sct/v1alpha1/sct.pb.go +++ b/proto/go/gen/penumbra/core/component/sct/v1alpha1/sct.pb.go @@ -1,13 +1,12 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.31.0 +// protoc-gen-go v1.32.0 // protoc (unknown) // source: penumbra/core/component/sct/v1alpha1/sct.proto package sctv1alpha1 import ( - _ "github.com/penumbra-zone/penumbra/proto/go/gen/penumbra/core/component/chain/v1alpha1" v1alpha1 "github.com/penumbra-zone/penumbra/proto/go/gen/penumbra/crypto/tct/v1alpha1" protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" @@ -742,123 +741,120 @@ var file_penumbra_core_component_sct_v1alpha1_sct_proto_rawDesc = []byte{ 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x73, 0x63, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x24, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x73, 0x63, 0x74, 0x2e, 0x76, 0x31, - 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x1a, 0x32, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, - 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2f, - 0x63, 0x68, 0x61, 0x69, 0x6e, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x63, - 0x68, 0x61, 0x69, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x26, 0x70, 0x65, 0x6e, 0x75, - 0x6d, 0x62, 0x72, 0x61, 0x2f, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2f, 0x74, 0x63, 0x74, 0x2f, - 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2f, 0x74, 0x63, 0x74, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x22, 0x8c, 0x06, 0x0a, 0x10, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, - 0x74, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x12, 0x66, 0x0a, 0x0b, 0x74, 0x72, 0x61, 0x6e, 0x73, - 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x42, 0x2e, 0x70, - 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, - 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x73, 0x63, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, - 0x68, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x6f, - 0x75, 0x72, 0x63, 0x65, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, - 0x48, 0x00, 0x52, 0x0b, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, - 0x6e, 0x0a, 0x0f, 0x69, 0x63, 0x73, 0x5f, 0x32, 0x30, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, - 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x44, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, + 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x1a, 0x26, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, + 0x2f, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2f, 0x74, 0x63, 0x74, 0x2f, 0x76, 0x31, 0x61, 0x6c, + 0x70, 0x68, 0x61, 0x31, 0x2f, 0x74, 0x63, 0x74, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x8c, + 0x06, 0x0a, 0x10, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x12, 0x66, 0x0a, 0x0b, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x42, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x73, 0x63, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, - 0x2e, 0x49, 0x63, 0x73, 0x32, 0x30, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x48, 0x00, - 0x52, 0x0d, 0x69, 0x63, 0x73, 0x32, 0x30, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x12, - 0x80, 0x01, 0x0a, 0x15, 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x74, 0x72, 0x65, - 0x61, 0x6d, 0x5f, 0x72, 0x65, 0x77, 0x61, 0x72, 0x64, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x4a, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, - 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x73, 0x63, 0x74, 0x2e, 0x76, 0x31, - 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, - 0x74, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x53, - 0x74, 0x72, 0x65, 0x61, 0x6d, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x48, 0x00, 0x52, 0x13, 0x66, - 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x52, 0x65, 0x77, 0x61, - 0x72, 0x64, 0x12, 0x61, 0x0a, 0x0a, 0x64, 0x61, 0x6f, 0x5f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, - 0x18, 0x1e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x40, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, - 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, - 0x2e, 0x73, 0x63, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, 0x6f, - 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x44, - 0x61, 0x6f, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x48, 0x00, 0x52, 0x09, 0x64, 0x61, 0x6f, 0x4f, - 0x75, 0x74, 0x70, 0x75, 0x74, 0x12, 0x5a, 0x0a, 0x07, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, - 0x18, 0x28, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x3e, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, - 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, - 0x2e, 0x73, 0x63, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, 0x6f, - 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x47, - 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x48, 0x00, 0x52, 0x07, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, - 0x73, 0x1a, 0x09, 0x0a, 0x07, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x1a, 0x1d, 0x0a, 0x0b, - 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x0e, 0x0a, 0x02, 0x69, - 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x02, 0x69, 0x64, 0x1a, 0x36, 0x0a, 0x13, 0x46, - 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x52, 0x65, 0x77, 0x61, - 0x72, 0x64, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64, 0x65, - 0x78, 0x18, 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0a, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x6e, - 0x64, 0x65, 0x78, 0x1a, 0x0b, 0x0a, 0x09, 0x44, 0x61, 0x6f, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, - 0x1a, 0x65, 0x0a, 0x0d, 0x49, 0x63, 0x73, 0x32, 0x30, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, - 0x72, 0x12, 0x1d, 0x0a, 0x0a, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x5f, 0x73, 0x65, 0x71, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x65, 0x71, - 0x12, 0x1d, 0x0a, 0x0a, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x49, 0x64, 0x12, - 0x16, 0x0a, 0x06, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x06, 0x73, 0x65, 0x6e, 0x64, 0x65, 0x72, 0x42, 0x08, 0x0a, 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, - 0x65, 0x22, 0x21, 0x0a, 0x09, 0x4e, 0x75, 0x6c, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x14, - 0x0a, 0x05, 0x69, 0x6e, 0x6e, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x69, - 0x6e, 0x6e, 0x65, 0x72, 0x22, 0x46, 0x0a, 0x11, 0x4e, 0x75, 0x6c, 0x6c, 0x69, 0x66, 0x69, 0x63, - 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x02, 0x69, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x70, 0x65, - 0x6e, 0x64, 0x5f, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, - 0x0b, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0xcc, 0x01, 0x0a, - 0x0f, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, - 0x12, 0x4d, 0x0a, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, - 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2e, 0x74, 0x63, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, - 0x68, 0x61, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, - 0x65, 0x6e, 0x74, 0x52, 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x12, - 0x1a, 0x0a, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x04, 0x52, 0x08, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x4e, 0x0a, 0x06, 0x73, - 0x6f, 0x75, 0x72, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x70, 0x65, + 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x0b, + 0x74, 0x72, 0x61, 0x6e, 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x6e, 0x0a, 0x0f, 0x69, + 0x63, 0x73, 0x5f, 0x32, 0x30, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x44, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x73, + 0x63, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, + 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x49, 0x63, 0x73, + 0x32, 0x30, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x48, 0x00, 0x52, 0x0d, 0x69, 0x63, + 0x73, 0x32, 0x30, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x12, 0x80, 0x01, 0x0a, 0x15, + 0x66, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x5f, 0x72, + 0x65, 0x77, 0x61, 0x72, 0x64, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x4a, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x73, 0x63, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x6f, 0x75, - 0x72, 0x63, 0x65, 0x52, 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x22, 0x67, 0x0a, 0x0b, 0x45, - 0x76, 0x65, 0x6e, 0x74, 0x41, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x12, 0x40, 0x0a, 0x06, 0x61, 0x6e, - 0x63, 0x68, 0x6f, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x70, 0x65, 0x6e, - 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2e, 0x74, 0x63, 0x74, - 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4d, 0x65, 0x72, 0x6b, 0x6c, 0x65, - 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x06, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x12, 0x16, 0x0a, 0x06, - 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x68, 0x65, - 0x69, 0x67, 0x68, 0x74, 0x22, 0x64, 0x0a, 0x0e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x45, 0x70, 0x6f, - 0x63, 0x68, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x3c, 0x0a, 0x04, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, - 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2e, 0x74, 0x63, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, - 0x68, 0x61, 0x31, 0x2e, 0x4d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x04, - 0x72, 0x6f, 0x6f, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x04, 0x52, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x66, 0x0a, 0x0e, 0x45, 0x76, - 0x65, 0x6e, 0x74, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x3c, 0x0a, 0x04, - 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x70, 0x65, 0x6e, - 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2e, 0x74, 0x63, 0x74, - 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4d, 0x65, 0x72, 0x6b, 0x6c, 0x65, - 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x04, 0x72, 0x6f, 0x6f, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x68, 0x65, - 0x69, 0x67, 0x68, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x68, 0x65, 0x69, 0x67, - 0x68, 0x74, 0x32, 0x0e, 0x0a, 0x0c, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x65, 0x72, 0x76, 0x69, - 0x63, 0x65, 0x42, 0xca, 0x02, 0x0a, 0x28, 0x63, 0x6f, 0x6d, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, - 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, - 0x6e, 0x74, 0x2e, 0x73, 0x63, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x42, - 0x08, 0x53, 0x63, 0x74, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x5f, 0x67, 0x69, 0x74, - 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, - 0x2d, 0x7a, 0x6f, 0x6e, 0x65, 0x2f, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2f, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x70, 0x65, 0x6e, 0x75, - 0x6d, 0x62, 0x72, 0x61, 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, - 0x65, 0x6e, 0x74, 0x2f, 0x73, 0x63, 0x74, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, - 0x3b, 0x73, 0x63, 0x74, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0xa2, 0x02, 0x04, 0x50, - 0x43, 0x43, 0x53, 0xaa, 0x02, 0x24, 0x50, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x43, - 0x6f, 0x72, 0x65, 0x2e, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x53, 0x63, - 0x74, 0x2e, 0x56, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0xca, 0x02, 0x24, 0x50, 0x65, 0x6e, - 0x75, 0x6d, 0x62, 0x72, 0x61, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x43, 0x6f, 0x6d, 0x70, 0x6f, - 0x6e, 0x65, 0x6e, 0x74, 0x5c, 0x53, 0x63, 0x74, 0x5c, 0x56, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, - 0x31, 0xe2, 0x02, 0x30, 0x50, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x5c, 0x43, 0x6f, 0x72, - 0x65, 0x5c, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x5c, 0x53, 0x63, 0x74, 0x5c, - 0x56, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, - 0x64, 0x61, 0x74, 0x61, 0xea, 0x02, 0x28, 0x50, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x3a, - 0x3a, 0x43, 0x6f, 0x72, 0x65, 0x3a, 0x3a, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, - 0x3a, 0x3a, 0x53, 0x63, 0x74, 0x3a, 0x3a, 0x56, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x62, - 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x72, 0x63, 0x65, 0x2e, 0x46, 0x75, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x53, 0x74, 0x72, 0x65, 0x61, + 0x6d, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x48, 0x00, 0x52, 0x13, 0x66, 0x75, 0x6e, 0x64, 0x69, + 0x6e, 0x67, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x12, 0x61, + 0x0a, 0x0a, 0x64, 0x61, 0x6f, 0x5f, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x18, 0x1e, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x40, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x73, 0x63, 0x74, + 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, + 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x44, 0x61, 0x6f, 0x4f, 0x75, + 0x74, 0x70, 0x75, 0x74, 0x48, 0x00, 0x52, 0x09, 0x64, 0x61, 0x6f, 0x4f, 0x75, 0x74, 0x70, 0x75, + 0x74, 0x12, 0x5a, 0x0a, 0x07, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x18, 0x28, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x3e, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x6f, + 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x73, 0x63, 0x74, + 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, + 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x2e, 0x47, 0x65, 0x6e, 0x65, 0x73, + 0x69, 0x73, 0x48, 0x00, 0x52, 0x07, 0x67, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x1a, 0x09, 0x0a, + 0x07, 0x47, 0x65, 0x6e, 0x65, 0x73, 0x69, 0x73, 0x1a, 0x1d, 0x0a, 0x0b, 0x54, 0x72, 0x61, 0x6e, + 0x73, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x0c, 0x52, 0x02, 0x69, 0x64, 0x1a, 0x36, 0x0a, 0x13, 0x46, 0x75, 0x6e, 0x64, 0x69, + 0x6e, 0x67, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x52, 0x65, 0x77, 0x61, 0x72, 0x64, 0x12, 0x1f, + 0x0a, 0x0b, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x04, 0x52, 0x0a, 0x65, 0x70, 0x6f, 0x63, 0x68, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x1a, + 0x0b, 0x0a, 0x09, 0x44, 0x61, 0x6f, 0x4f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x1a, 0x65, 0x0a, 0x0d, + 0x49, 0x63, 0x73, 0x32, 0x30, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x12, 0x1d, 0x0a, + 0x0a, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x5f, 0x73, 0x65, 0x71, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x04, 0x52, 0x09, 0x70, 0x61, 0x63, 0x6b, 0x65, 0x74, 0x53, 0x65, 0x71, 0x12, 0x1d, 0x0a, 0x0a, + 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x09, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x73, + 0x65, 0x6e, 0x64, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x73, 0x65, 0x6e, + 0x64, 0x65, 0x72, 0x42, 0x08, 0x0a, 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x22, 0x21, 0x0a, + 0x09, 0x4e, 0x75, 0x6c, 0x6c, 0x69, 0x66, 0x69, 0x65, 0x72, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6e, + 0x6e, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05, 0x69, 0x6e, 0x6e, 0x65, 0x72, + 0x22, 0x46, 0x0a, 0x11, 0x4e, 0x75, 0x6c, 0x6c, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0c, 0x52, 0x02, 0x69, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x5f, 0x68, + 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0b, 0x73, 0x70, 0x65, + 0x6e, 0x64, 0x48, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0xcc, 0x01, 0x0a, 0x0f, 0x45, 0x76, 0x65, + 0x6e, 0x74, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x4d, 0x0a, 0x0a, + 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x2d, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x72, 0x79, 0x70, + 0x74, 0x6f, 0x2e, 0x74, 0x63, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, + 0x53, 0x74, 0x61, 0x74, 0x65, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x52, + 0x0a, 0x63, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x1a, 0x0a, 0x08, 0x70, + 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x08, 0x70, + 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x4e, 0x0a, 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x36, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, + 0x72, 0x61, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, + 0x74, 0x2e, 0x73, 0x63, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x43, + 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x52, + 0x06, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x22, 0x67, 0x0a, 0x0b, 0x45, 0x76, 0x65, 0x6e, 0x74, + 0x41, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x12, 0x40, 0x0a, 0x06, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, + 0x61, 0x2e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2e, 0x74, 0x63, 0x74, 0x2e, 0x76, 0x31, 0x61, + 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x52, 0x6f, 0x6f, 0x74, + 0x52, 0x06, 0x61, 0x6e, 0x63, 0x68, 0x6f, 0x72, 0x12, 0x16, 0x0a, 0x06, 0x68, 0x65, 0x69, 0x67, + 0x68, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, + 0x22, 0x64, 0x0a, 0x0e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x45, 0x70, 0x6f, 0x63, 0x68, 0x52, 0x6f, + 0x6f, 0x74, 0x12, 0x3c, 0x0a, 0x04, 0x72, 0x6f, 0x6f, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x28, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x63, 0x72, 0x79, 0x70, + 0x74, 0x6f, 0x2e, 0x74, 0x63, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, + 0x4d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x52, 0x6f, 0x6f, 0x74, 0x52, 0x04, 0x72, 0x6f, 0x6f, 0x74, + 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, + 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x66, 0x0a, 0x0e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x42, + 0x6c, 0x6f, 0x63, 0x6b, 0x52, 0x6f, 0x6f, 0x74, 0x12, 0x3c, 0x0a, 0x04, 0x72, 0x6f, 0x6f, 0x74, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x28, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, + 0x61, 0x2e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x6f, 0x2e, 0x74, 0x63, 0x74, 0x2e, 0x76, 0x31, 0x61, + 0x6c, 0x70, 0x68, 0x61, 0x31, 0x2e, 0x4d, 0x65, 0x72, 0x6b, 0x6c, 0x65, 0x52, 0x6f, 0x6f, 0x74, + 0x52, 0x04, 0x72, 0x6f, 0x6f, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x04, 0x52, 0x06, 0x68, 0x65, 0x69, 0x67, 0x68, 0x74, 0x32, 0x0e, + 0x0a, 0x0c, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x42, 0xca, + 0x02, 0x0a, 0x28, 0x63, 0x6f, 0x6d, 0x2e, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, + 0x63, 0x6f, 0x72, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x73, + 0x63, 0x74, 0x2e, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x42, 0x08, 0x53, 0x63, 0x74, + 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x5f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, + 0x63, 0x6f, 0x6d, 0x2f, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2d, 0x7a, 0x6f, 0x6e, + 0x65, 0x2f, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2f, 0x67, 0x6f, 0x2f, 0x67, 0x65, 0x6e, 0x2f, 0x70, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, + 0x2f, 0x63, 0x6f, 0x72, 0x65, 0x2f, 0x63, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2f, + 0x73, 0x63, 0x74, 0x2f, 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x3b, 0x73, 0x63, 0x74, + 0x76, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0xa2, 0x02, 0x04, 0x50, 0x43, 0x43, 0x53, 0xaa, + 0x02, 0x24, 0x50, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x2e, 0x43, 0x6f, 0x72, 0x65, 0x2e, + 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x2e, 0x53, 0x63, 0x74, 0x2e, 0x56, 0x31, + 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0xca, 0x02, 0x24, 0x50, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, + 0x61, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, + 0x5c, 0x53, 0x63, 0x74, 0x5c, 0x56, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0xe2, 0x02, 0x30, + 0x50, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x5c, 0x43, 0x6f, 0x72, 0x65, 0x5c, 0x43, 0x6f, + 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x5c, 0x53, 0x63, 0x74, 0x5c, 0x56, 0x31, 0x61, 0x6c, + 0x70, 0x68, 0x61, 0x31, 0x5c, 0x47, 0x50, 0x42, 0x4d, 0x65, 0x74, 0x61, 0x64, 0x61, 0x74, 0x61, + 0xea, 0x02, 0x28, 0x50, 0x65, 0x6e, 0x75, 0x6d, 0x62, 0x72, 0x61, 0x3a, 0x3a, 0x43, 0x6f, 0x72, + 0x65, 0x3a, 0x3a, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x3a, 0x3a, 0x53, 0x63, + 0x74, 0x3a, 0x3a, 0x56, 0x31, 0x61, 0x6c, 0x70, 0x68, 0x61, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x33, } var ( diff --git a/proto/go/gen/penumbra/core/component/shielded_pool/v1alpha1/shielded_pool.pb.go b/proto/go/gen/penumbra/core/component/shielded_pool/v1alpha1/shielded_pool.pb.go index 251ab2cb60..ff9964f34e 100644 --- a/proto/go/gen/penumbra/core/component/shielded_pool/v1alpha1/shielded_pool.pb.go +++ b/proto/go/gen/penumbra/core/component/shielded_pool/v1alpha1/shielded_pool.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.31.0 +// protoc-gen-go v1.32.0 // protoc (unknown) // source: penumbra/core/component/shielded_pool/v1alpha1/shielded_pool.proto diff --git a/proto/go/gen/penumbra/core/component/stake/v1alpha1/stake.pb.go b/proto/go/gen/penumbra/core/component/stake/v1alpha1/stake.pb.go index 7b9cf777de..a44b11cbf5 100644 --- a/proto/go/gen/penumbra/core/component/stake/v1alpha1/stake.pb.go +++ b/proto/go/gen/penumbra/core/component/stake/v1alpha1/stake.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.31.0 +// protoc-gen-go v1.32.0 // protoc (unknown) // source: penumbra/core/component/stake/v1alpha1/stake.proto diff --git a/proto/go/gen/penumbra/core/keys/v1alpha1/keys.pb.go b/proto/go/gen/penumbra/core/keys/v1alpha1/keys.pb.go index baec8b610b..ca4a0d54cb 100644 --- a/proto/go/gen/penumbra/core/keys/v1alpha1/keys.pb.go +++ b/proto/go/gen/penumbra/core/keys/v1alpha1/keys.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.31.0 +// protoc-gen-go v1.32.0 // protoc (unknown) // source: penumbra/core/keys/v1alpha1/keys.proto diff --git a/proto/go/gen/penumbra/core/num/v1alpha1/num.pb.go b/proto/go/gen/penumbra/core/num/v1alpha1/num.pb.go index 216c2ebd29..6c8b9b629e 100644 --- a/proto/go/gen/penumbra/core/num/v1alpha1/num.pb.go +++ b/proto/go/gen/penumbra/core/num/v1alpha1/num.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.31.0 +// protoc-gen-go v1.32.0 // protoc (unknown) // source: penumbra/core/num/v1alpha1/num.proto diff --git a/proto/go/gen/penumbra/core/transaction/v1alpha1/transaction.pb.go b/proto/go/gen/penumbra/core/transaction/v1alpha1/transaction.pb.go index 7dfffb9a29..0cc8bfbb2b 100644 --- a/proto/go/gen/penumbra/core/transaction/v1alpha1/transaction.pb.go +++ b/proto/go/gen/penumbra/core/transaction/v1alpha1/transaction.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.31.0 +// protoc-gen-go v1.32.0 // protoc (unknown) // source: penumbra/core/transaction/v1alpha1/transaction.proto diff --git a/proto/go/gen/penumbra/crypto/decaf377_fmd/v1alpha1/decaf377_fmd.pb.go b/proto/go/gen/penumbra/crypto/decaf377_fmd/v1alpha1/decaf377_fmd.pb.go index 38531f67f7..1be2be4dc7 100644 --- a/proto/go/gen/penumbra/crypto/decaf377_fmd/v1alpha1/decaf377_fmd.pb.go +++ b/proto/go/gen/penumbra/crypto/decaf377_fmd/v1alpha1/decaf377_fmd.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.31.0 +// protoc-gen-go v1.32.0 // protoc (unknown) // source: penumbra/crypto/decaf377_fmd/v1alpha1/decaf377_fmd.proto diff --git a/proto/go/gen/penumbra/crypto/decaf377_frost/v1alpha1/decaf377_frost.pb.go b/proto/go/gen/penumbra/crypto/decaf377_frost/v1alpha1/decaf377_frost.pb.go index 7fd91635ca..f85fc0d860 100644 --- a/proto/go/gen/penumbra/crypto/decaf377_frost/v1alpha1/decaf377_frost.pb.go +++ b/proto/go/gen/penumbra/crypto/decaf377_frost/v1alpha1/decaf377_frost.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.31.0 +// protoc-gen-go v1.32.0 // protoc (unknown) // source: penumbra/crypto/decaf377_frost/v1alpha1/decaf377_frost.proto diff --git a/proto/go/gen/penumbra/crypto/decaf377_rdsa/v1alpha1/decaf377_rdsa.pb.go b/proto/go/gen/penumbra/crypto/decaf377_rdsa/v1alpha1/decaf377_rdsa.pb.go index c4bb76d1f1..454bad2be6 100644 --- a/proto/go/gen/penumbra/crypto/decaf377_rdsa/v1alpha1/decaf377_rdsa.pb.go +++ b/proto/go/gen/penumbra/crypto/decaf377_rdsa/v1alpha1/decaf377_rdsa.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.31.0 +// protoc-gen-go v1.32.0 // protoc (unknown) // source: penumbra/crypto/decaf377_rdsa/v1alpha1/decaf377_rdsa.proto diff --git a/proto/go/gen/penumbra/crypto/tct/v1alpha1/tct.pb.go b/proto/go/gen/penumbra/crypto/tct/v1alpha1/tct.pb.go index 6f9654a172..99f0b24784 100644 --- a/proto/go/gen/penumbra/crypto/tct/v1alpha1/tct.pb.go +++ b/proto/go/gen/penumbra/crypto/tct/v1alpha1/tct.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.31.0 +// protoc-gen-go v1.32.0 // protoc (unknown) // source: penumbra/crypto/tct/v1alpha1/tct.proto diff --git a/proto/go/gen/penumbra/custody/threshold/v1alpha1/threshold.pb.go b/proto/go/gen/penumbra/custody/threshold/v1alpha1/threshold.pb.go index f232d28662..3a1cf1bf33 100644 --- a/proto/go/gen/penumbra/custody/threshold/v1alpha1/threshold.pb.go +++ b/proto/go/gen/penumbra/custody/threshold/v1alpha1/threshold.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.31.0 +// protoc-gen-go v1.32.0 // protoc (unknown) // source: penumbra/custody/threshold/v1alpha1/threshold.proto diff --git a/proto/go/gen/penumbra/custody/v1alpha1/custody.pb.go b/proto/go/gen/penumbra/custody/v1alpha1/custody.pb.go index 7f265f2924..c76f5eb911 100644 --- a/proto/go/gen/penumbra/custody/v1alpha1/custody.pb.go +++ b/proto/go/gen/penumbra/custody/v1alpha1/custody.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.31.0 +// protoc-gen-go v1.32.0 // protoc (unknown) // source: penumbra/custody/v1alpha1/custody.proto diff --git a/proto/go/gen/penumbra/tools/summoning/v1alpha1/summoning.pb.go b/proto/go/gen/penumbra/tools/summoning/v1alpha1/summoning.pb.go index fcb9d95636..34766389ad 100644 --- a/proto/go/gen/penumbra/tools/summoning/v1alpha1/summoning.pb.go +++ b/proto/go/gen/penumbra/tools/summoning/v1alpha1/summoning.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.31.0 +// protoc-gen-go v1.32.0 // protoc (unknown) // source: penumbra/tools/summoning/v1alpha1/summoning.proto diff --git a/proto/go/gen/penumbra/util/tendermint_proxy/v1alpha1/tendermint_proxy.pb.go b/proto/go/gen/penumbra/util/tendermint_proxy/v1alpha1/tendermint_proxy.pb.go index 926f710aa1..09dcc4bdc9 100644 --- a/proto/go/gen/penumbra/util/tendermint_proxy/v1alpha1/tendermint_proxy.pb.go +++ b/proto/go/gen/penumbra/util/tendermint_proxy/v1alpha1/tendermint_proxy.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.31.0 +// protoc-gen-go v1.32.0 // protoc (unknown) // source: penumbra/util/tendermint_proxy/v1alpha1/tendermint_proxy.proto diff --git a/proto/go/gen/penumbra/view/v1alpha1/view.pb.go b/proto/go/gen/penumbra/view/v1alpha1/view.pb.go index ccbf528888..55d0a710b5 100644 --- a/proto/go/gen/penumbra/view/v1alpha1/view.pb.go +++ b/proto/go/gen/penumbra/view/v1alpha1/view.pb.go @@ -1,6 +1,6 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: -// protoc-gen-go v1.31.0 +// protoc-gen-go v1.32.0 // protoc (unknown) // source: penumbra/view/v1alpha1/view.proto diff --git a/proto/penumbra/penumbra/cnidarium/v1alpha1/cnidarium.proto b/proto/penumbra/penumbra/cnidarium/v1alpha1/cnidarium.proto index 0d6584598b..dc1f14d084 100644 --- a/proto/penumbra/penumbra/cnidarium/v1alpha1/cnidarium.proto +++ b/proto/penumbra/penumbra/cnidarium/v1alpha1/cnidarium.proto @@ -11,8 +11,10 @@ service QueryService { // General-purpose prefixed key-value state query API, that can be used to query // arbitrary prefixes in the JMT storage. - // Returns a stream of `PrefixValueResponse`s. rpc PrefixValue(PrefixValueRequest) returns (stream PrefixValueResponse); + + // Subscribes to a stream of key-value updates, with regex filtering on keys. + rpc Watch(WatchRequest) returns (stream WatchResponse); } // Performs a key-value query, either by key or by key hash. @@ -49,3 +51,48 @@ message PrefixValueResponse { string key = 1; bytes value = 2; } + +// Requests a stream of new key-value pairs that have been committed to the state. +message WatchRequest { + // A regex for keys in the verifiable storage. + // + // Only key-value updates whose keys match this regex will be returned. + // Note that the empty string matches all keys. + // To exclude all keys, use the regex "$^", which matches no strings. + string key_regex = 1; + // A regex for keys in the nonverifiable storage. + // + // Only key-value updates whose keys match this regex will be returned. + // Note that the empty string matches all keys. + // To exclude all keys, use the regex "$^", which matches no strings. + string nv_key_regex = 2; +} + +// A key-value pair that has been committed to the state. +message WatchResponse { + // Elements of the verifiable storage have string keys. + message KeyValue { + string key = 1; + bytes value = 2; + // If set to true, the key-value pair was deleted. + // This allows distinguishing a deleted key-value pair from a key-value pair whose value is empty. + bool deleted = 3; + } + // Elements of the nonverifiable storage have byte keys. + message NvKeyValue { + bytes key = 1; + bytes value = 2; + // If set to true, the key-value pair was deleted. + // This allows distinguishing a deleted key-value pair from a key-value pair whose value is empty. + bool deleted = 3; + } + + // The state version the key-value pair was committed at. + uint64 version = 1; + + // The entry that was committed. + oneof entry { + KeyValue kv = 5; + NvKeyValue nv_kv = 6; + } +} \ No newline at end of file