diff --git a/crates/proto/src/gen/penumbra.view.v1.rs b/crates/proto/src/gen/penumbra.view.v1.rs index b2656ba48d..510a0b8337 100644 --- a/crates/proto/src/gen/penumbra.view.v1.rs +++ b/crates/proto/src/gen/penumbra.view.v1.rs @@ -247,6 +247,8 @@ pub struct TransactionPlannerRequest { /// Request contents #[prost(message, repeated, tag = "20")] pub outputs: ::prost::alloc::vec::Vec, + #[prost(message, repeated, tag = "21")] + pub spends: ::prost::alloc::vec::Vec, #[prost(message, repeated, tag = "30")] pub swaps: ::prost::alloc::vec::Vec, #[prost(message, repeated, tag = "31")] @@ -328,6 +330,27 @@ pub mod transaction_planner_request { } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] + pub struct Spend { + /// The input amount and denomination in which the Spend is issued. + #[prost(message, optional, tag = "1")] + pub value: ::core::option::Option, + /// The source address from which the Spend will be sent. + #[prost(message, optional, tag = "2")] + pub address: ::core::option::Option< + super::super::super::core::keys::v1::Address, + >, + } + impl ::prost::Name for Spend { + const NAME: &'static str = "Spend"; + const PACKAGE: &'static str = "penumbra.view.v1"; + fn full_name() -> ::prost::alloc::string::String { + ::prost::alloc::format!( + "penumbra.view.v1.TransactionPlannerRequest.{}", Self::NAME + ) + } + } + #[allow(clippy::derive_partial_eq_without_eq)] + #[derive(Clone, PartialEq, ::prost::Message)] pub struct Swap { /// The input amount and denomination to be traded in the Swap. #[prost(message, optional, tag = "1")] diff --git a/crates/proto/src/gen/penumbra.view.v1.serde.rs b/crates/proto/src/gen/penumbra.view.v1.serde.rs index 1fb7de41cf..690ecde476 100644 --- a/crates/proto/src/gen/penumbra.view.v1.serde.rs +++ b/crates/proto/src/gen/penumbra.view.v1.serde.rs @@ -6068,6 +6068,9 @@ impl serde::Serialize for TransactionPlannerRequest { if !self.outputs.is_empty() { len += 1; } + if !self.spends.is_empty() { + len += 1; + } if !self.swaps.is_empty() { len += 1; } @@ -6130,6 +6133,9 @@ impl serde::Serialize for TransactionPlannerRequest { if !self.outputs.is_empty() { struct_ser.serialize_field("outputs", &self.outputs)?; } + if !self.spends.is_empty() { + struct_ser.serialize_field("spends", &self.spends)?; + } if !self.swaps.is_empty() { struct_ser.serialize_field("swaps", &self.swaps)?; } @@ -6201,6 +6207,7 @@ impl<'de> serde::Deserialize<'de> for TransactionPlannerRequest { "memo", "source", "outputs", + "spends", "swaps", "swap_claims", "swapClaims", @@ -6239,6 +6246,7 @@ impl<'de> serde::Deserialize<'de> for TransactionPlannerRequest { Memo, Source, Outputs, + Spends, Swaps, SwapClaims, Delegations, @@ -6282,6 +6290,7 @@ impl<'de> serde::Deserialize<'de> for TransactionPlannerRequest { "memo" => Ok(GeneratedField::Memo), "source" => Ok(GeneratedField::Source), "outputs" => Ok(GeneratedField::Outputs), + "spends" => Ok(GeneratedField::Spends), "swaps" => Ok(GeneratedField::Swaps), "swapClaims" | "swap_claims" => Ok(GeneratedField::SwapClaims), "delegations" => Ok(GeneratedField::Delegations), @@ -6322,6 +6331,7 @@ impl<'de> serde::Deserialize<'de> for TransactionPlannerRequest { let mut memo__ = None; let mut source__ = None; let mut outputs__ = None; + let mut spends__ = None; let mut swaps__ = None; let mut swap_claims__ = None; let mut delegations__ = None; @@ -6366,6 +6376,12 @@ impl<'de> serde::Deserialize<'de> for TransactionPlannerRequest { } outputs__ = Some(map_.next_value()?); } + GeneratedField::Spends => { + if spends__.is_some() { + return Err(serde::de::Error::duplicate_field("spends")); + } + spends__ = Some(map_.next_value()?); + } GeneratedField::Swaps => { if swaps__.is_some() { return Err(serde::de::Error::duplicate_field("swaps")); @@ -6482,6 +6498,7 @@ impl<'de> serde::Deserialize<'de> for TransactionPlannerRequest { memo: memo__, source: source__, outputs: outputs__.unwrap_or_default(), + spends: spends__.unwrap_or_default(), swaps: swaps__.unwrap_or_default(), swap_claims: swap_claims__.unwrap_or_default(), delegations: delegations__.unwrap_or_default(), @@ -7358,6 +7375,118 @@ impl<'de> serde::Deserialize<'de> for transaction_planner_request::PositionWithd deserializer.deserialize_struct("penumbra.view.v1.TransactionPlannerRequest.PositionWithdraw", FIELDS, GeneratedVisitor) } } +impl serde::Serialize for transaction_planner_request::Spend { + #[allow(deprecated)] + fn serialize(&self, serializer: S) -> std::result::Result + where + S: serde::Serializer, + { + use serde::ser::SerializeStruct; + let mut len = 0; + if self.value.is_some() { + len += 1; + } + if self.address.is_some() { + len += 1; + } + let mut struct_ser = serializer.serialize_struct("penumbra.view.v1.TransactionPlannerRequest.Spend", len)?; + if let Some(v) = self.value.as_ref() { + struct_ser.serialize_field("value", v)?; + } + if let Some(v) = self.address.as_ref() { + struct_ser.serialize_field("address", v)?; + } + struct_ser.end() + } +} +impl<'de> serde::Deserialize<'de> for transaction_planner_request::Spend { + #[allow(deprecated)] + fn deserialize(deserializer: D) -> std::result::Result + where + D: serde::Deserializer<'de>, + { + const FIELDS: &[&str] = &[ + "value", + "address", + ]; + + #[allow(clippy::enum_variant_names)] + enum GeneratedField { + Value, + Address, + __SkipField__, + } + 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 { + "value" => Ok(GeneratedField::Value), + "address" => Ok(GeneratedField::Address), + _ => Ok(GeneratedField::__SkipField__), + } + } + } + deserializer.deserialize_identifier(GeneratedVisitor) + } + } + struct GeneratedVisitor; + impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { + type Value = transaction_planner_request::Spend; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("struct penumbra.view.v1.TransactionPlannerRequest.Spend") + } + + fn visit_map(self, mut map_: V) -> std::result::Result + where + V: serde::de::MapAccess<'de>, + { + let mut value__ = None; + let mut address__ = None; + while let Some(k) = map_.next_key()? { + match k { + GeneratedField::Value => { + if value__.is_some() { + return Err(serde::de::Error::duplicate_field("value")); + } + value__ = map_.next_value()?; + } + GeneratedField::Address => { + if address__.is_some() { + return Err(serde::de::Error::duplicate_field("address")); + } + address__ = map_.next_value()?; + } + GeneratedField::__SkipField__ => { + let _ = map_.next_value::()?; + } + } + } + Ok(transaction_planner_request::Spend { + value: value__, + address: address__, + }) + } + } + deserializer.deserialize_struct("penumbra.view.v1.TransactionPlannerRequest.Spend", FIELDS, GeneratedVisitor) + } +} impl serde::Serialize for transaction_planner_request::Swap { #[allow(deprecated)] fn serialize(&self, serializer: S) -> std::result::Result diff --git a/crates/proto/src/gen/proto_descriptor.bin.no_lfs b/crates/proto/src/gen/proto_descriptor.bin.no_lfs index ca3ac1c8d0..45f65d2eaa 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/deployments/scripts/protobuf-codegen b/deployments/scripts/protobuf-codegen index 2765293cb0..5c16ebd908 100755 --- a/deployments/scripts/protobuf-codegen +++ b/deployments/scripts/protobuf-codegen @@ -16,7 +16,7 @@ done echo "Pulling proto dependencies from BSR..." pushd "${repo_root}/proto/" # Make sure the lockfile is up to date. -buf dep update penumbra +buf mod update penumbra # Pull our vendored cosmos/IBC proto defs so we can get reflection for service definitions. # The penumbra dependencies will override some of these. diff --git a/proto/penumbra/penumbra/view/v1/view.proto b/proto/penumbra/penumbra/view/v1/view.proto index a4d6aec6c8..6f00af9635 100644 --- a/proto/penumbra/penumbra/view/v1/view.proto +++ b/proto/penumbra/penumbra/view/v1/view.proto @@ -247,6 +247,7 @@ message TransactionPlannerRequest { // Request contents repeated Output outputs = 20; + repeated Spend spends = 21; repeated Swap swaps = 30; repeated SwapClaim swap_claims = 31; repeated Delegate delegations = 40; @@ -282,6 +283,12 @@ message TransactionPlannerRequest { // The address to which Output will be sent. core.keys.v1.Address address = 2; } + message Spend { + // The input amount and denomination in which the Spend is issued. + core.asset.v1.Value value = 1; + // The source address from which the Spend will be sent. + core.keys.v1.Address address = 2; + } message Swap { // The input amount and denomination to be traded in the Swap. core.asset.v1.Value value = 1; @@ -749,4 +756,4 @@ message UnbondingTokensByAddressIndexResponse { // `true` if the `unbonding_delay` (from `StakeParameters`) has passed or the // validator has unbonded. bool claimable = 2; -} +} \ No newline at end of file