From 34177b11079614cf1d649d098059ada6c78c1f24 Mon Sep 17 00:00:00 2001 From: Leigh McCulloch <351529+leighmcculloch@users.noreply.github.com> Date: Tue, 30 Jul 2024 11:26:44 +1000 Subject: [PATCH 1/3] Update xdrgen --- Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Makefile b/Makefile index 5f453f80..40623621 100644 --- a/Makefile +++ b/Makefile @@ -4,7 +4,7 @@ CARGO_HACK_ARGS=--feature-powerset --exclude-features default --group-features b CARGO_DOC_ARGS?=--open -XDRGEN_VERSION=ac1653599b97b298e72c0186b5685bffa120b6aa +XDRGEN_VERSION=691341a1958278b906a191044072e1f2ad29a8ce # XDRGEN_LOCAL=1 XDRGEN_TYPES_CUSTOM_STR_IMPL_CURR=PublicKey,AccountId,MuxedAccount,MuxedAccountMed25519,SignerKey,SignerKeyEd25519SignedPayload,NodeId,ScAddress,AssetCode,AssetCode4,AssetCode12,ClaimableBalanceId XDRGEN_TYPES_CUSTOM_STR_IMPL_NEXT=PublicKey,AccountId,MuxedAccount,MuxedAccountMed25519,SignerKey,SignerKeyEd25519SignedPayload,NodeId,ScAddress,AssetCode,AssetCode4,AssetCode12,ClaimableBalanceId From bb1cbfbed2cd3a6bf7fc387b8ddd229430b7fac2 Mon Sep 17 00:00:00 2001 From: Leigh McCulloch <351529+leighmcculloch@users.noreply.github.com> Date: Tue, 30 Jul 2024 13:24:19 +1000 Subject: [PATCH 2/3] update --- Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Makefile b/Makefile index 40623621..3484d7b2 100644 --- a/Makefile +++ b/Makefile @@ -4,7 +4,7 @@ CARGO_HACK_ARGS=--feature-powerset --exclude-features default --group-features b CARGO_DOC_ARGS?=--open -XDRGEN_VERSION=691341a1958278b906a191044072e1f2ad29a8ce +XDRGEN_VERSION=dda3c5ecea32847b7ab2333cfec602e892ae1478 # XDRGEN_LOCAL=1 XDRGEN_TYPES_CUSTOM_STR_IMPL_CURR=PublicKey,AccountId,MuxedAccount,MuxedAccountMed25519,SignerKey,SignerKeyEd25519SignedPayload,NodeId,ScAddress,AssetCode,AssetCode4,AssetCode12,ClaimableBalanceId XDRGEN_TYPES_CUSTOM_STR_IMPL_NEXT=PublicKey,AccountId,MuxedAccount,MuxedAccountMed25519,SignerKey,SignerKeyEd25519SignedPayload,NodeId,ScAddress,AssetCode,AssetCode4,AssetCode12,ClaimableBalanceId From fda0f42a95d622bba796bb9e3bc51f78dbd398bd Mon Sep 17 00:00:00 2001 From: Garand Tyson Date: Mon, 29 Jul 2024 22:07:12 -0700 Subject: [PATCH 3/3] Bump xdr --- src/curr/generated.rs | 352 ++++++++++++++++- src/next/generated.rs | 862 +++++++++++++++++++++++++++++++++++++++++- xdr/curr | 2 +- xdr/curr-version | 2 +- xdr/next | 2 +- xdr/next-version | 2 +- 6 files changed, 1192 insertions(+), 30 deletions(-) diff --git a/src/curr/generated.rs b/src/curr/generated.rs index bdbe7bee..f75a473a 100644 --- a/src/curr/generated.rs +++ b/src/curr/generated.rs @@ -62,7 +62,7 @@ pub const XDR_FILES_SHA256: [(&str, &str); 12] = [ ), ( "xdr/curr/Stellar-types.x", - "6e3b13f0d3e360b09fa5e2b0e55d43f4d974a769df66afb34e8aecbb329d3f15", + "253f515fc5e06bc938105e92a4c7f562251d4ebc178d39d6e6751e6b85fe1064", ), ]; @@ -44353,6 +44353,242 @@ impl WriteXdr for HmacSha256Mac { } } +/// ShortHashSeed is an XDR Struct defines as: +/// +/// ```text +/// struct ShortHashSeed +/// { +/// opaque seed[16]; +/// }; +/// ``` +/// +#[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)] +#[cfg_attr(feature = "arbitrary", derive(Arbitrary))] +#[cfg_attr( + all(feature = "serde", feature = "alloc"), + derive(serde::Serialize, serde::Deserialize), + serde(rename_all = "snake_case") +)] +#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))] +pub struct ShortHashSeed { + pub seed: [u8; 16], +} + +impl ReadXdr for ShortHashSeed { + #[cfg(feature = "std")] + fn read_xdr(r: &mut Limited) -> Result { + r.with_limited_depth(|r| { + Ok(Self { + seed: <[u8; 16]>::read_xdr(r)?, + }) + }) + } +} + +impl WriteXdr for ShortHashSeed { + #[cfg(feature = "std")] + fn write_xdr(&self, w: &mut Limited) -> Result<()> { + w.with_limited_depth(|w| { + self.seed.write_xdr(w)?; + Ok(()) + }) + } +} + +/// BinaryFuseFilterType is an XDR Enum defines as: +/// +/// ```text +/// enum BinaryFuseFilterType +/// { +/// BINARY_FUSE_FILTER_8_BIT = 0, +/// BINARY_FUSE_FILTER_16_BIT = 1, +/// BINARY_FUSE_FILTER_32_BIT = 2 +/// }; +/// ``` +/// +// enum +#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)] +#[cfg_attr(feature = "arbitrary", derive(Arbitrary))] +#[cfg_attr( + all(feature = "serde", feature = "alloc"), + derive(serde::Serialize, serde::Deserialize), + serde(rename_all = "snake_case") +)] +#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))] +#[repr(i32)] +pub enum BinaryFuseFilterType { + B8Bit = 0, + B16Bit = 1, + B32Bit = 2, +} + +impl BinaryFuseFilterType { + pub const VARIANTS: [BinaryFuseFilterType; 3] = [ + BinaryFuseFilterType::B8Bit, + BinaryFuseFilterType::B16Bit, + BinaryFuseFilterType::B32Bit, + ]; + pub const VARIANTS_STR: [&'static str; 3] = ["B8Bit", "B16Bit", "B32Bit"]; + + #[must_use] + pub const fn name(&self) -> &'static str { + match self { + Self::B8Bit => "B8Bit", + Self::B16Bit => "B16Bit", + Self::B32Bit => "B32Bit", + } + } + + #[must_use] + pub const fn variants() -> [BinaryFuseFilterType; 3] { + Self::VARIANTS + } +} + +impl Name for BinaryFuseFilterType { + #[must_use] + fn name(&self) -> &'static str { + Self::name(self) + } +} + +impl Variants for BinaryFuseFilterType { + fn variants() -> slice::Iter<'static, BinaryFuseFilterType> { + Self::VARIANTS.iter() + } +} + +impl Enum for BinaryFuseFilterType {} + +impl fmt::Display for BinaryFuseFilterType { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str(self.name()) + } +} + +impl TryFrom for BinaryFuseFilterType { + type Error = Error; + + fn try_from(i: i32) -> Result { + let e = match i { + 0 => BinaryFuseFilterType::B8Bit, + 1 => BinaryFuseFilterType::B16Bit, + 2 => BinaryFuseFilterType::B32Bit, + #[allow(unreachable_patterns)] + _ => return Err(Error::Invalid), + }; + Ok(e) + } +} + +impl From for i32 { + #[must_use] + fn from(e: BinaryFuseFilterType) -> Self { + e as Self + } +} + +impl ReadXdr for BinaryFuseFilterType { + #[cfg(feature = "std")] + fn read_xdr(r: &mut Limited) -> Result { + r.with_limited_depth(|r| { + let e = i32::read_xdr(r)?; + let v: Self = e.try_into()?; + Ok(v) + }) + } +} + +impl WriteXdr for BinaryFuseFilterType { + #[cfg(feature = "std")] + fn write_xdr(&self, w: &mut Limited) -> Result<()> { + w.with_limited_depth(|w| { + let i: i32 = (*self).into(); + i.write_xdr(w) + }) + } +} + +/// SerializedBinaryFuseFilter is an XDR Struct defines as: +/// +/// ```text +/// struct SerializedBinaryFuseFilter +/// { +/// BinaryFuseFilterType type; +/// +/// // Seed used to hash input to filter +/// ShortHashSeed inputHashSeed; +/// +/// // Seed used for internal filter hash operations +/// ShortHashSeed filterSeed; +/// uint32 segmentLength; +/// uint32 segementLengthMask; +/// uint32 segmentCount; +/// uint32 segmentCountLength; +/// uint32 fingerprintLength; // Length in terms of element count, not bytes +/// +/// // Array of uint8_t, uint16_t, or uint32_t depending on filter type +/// opaque fingerprints<>; +/// }; +/// ``` +/// +#[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)] +#[cfg_attr(feature = "arbitrary", derive(Arbitrary))] +#[cfg_attr( + all(feature = "serde", feature = "alloc"), + derive(serde::Serialize, serde::Deserialize), + serde(rename_all = "snake_case") +)] +#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))] +pub struct SerializedBinaryFuseFilter { + pub type_: BinaryFuseFilterType, + pub input_hash_seed: ShortHashSeed, + pub filter_seed: ShortHashSeed, + pub segment_length: u32, + pub segement_length_mask: u32, + pub segment_count: u32, + pub segment_count_length: u32, + pub fingerprint_length: u32, + pub fingerprints: BytesM, +} + +impl ReadXdr for SerializedBinaryFuseFilter { + #[cfg(feature = "std")] + fn read_xdr(r: &mut Limited) -> Result { + r.with_limited_depth(|r| { + Ok(Self { + type_: BinaryFuseFilterType::read_xdr(r)?, + input_hash_seed: ShortHashSeed::read_xdr(r)?, + filter_seed: ShortHashSeed::read_xdr(r)?, + segment_length: u32::read_xdr(r)?, + segement_length_mask: u32::read_xdr(r)?, + segment_count: u32::read_xdr(r)?, + segment_count_length: u32::read_xdr(r)?, + fingerprint_length: u32::read_xdr(r)?, + fingerprints: BytesM::read_xdr(r)?, + }) + }) + } +} + +impl WriteXdr for SerializedBinaryFuseFilter { + #[cfg(feature = "std")] + fn write_xdr(&self, w: &mut Limited) -> Result<()> { + w.with_limited_depth(|w| { + self.type_.write_xdr(w)?; + self.input_hash_seed.write_xdr(w)?; + self.filter_seed.write_xdr(w)?; + self.segment_length.write_xdr(w)?; + self.segement_length_mask.write_xdr(w)?; + self.segment_count.write_xdr(w)?; + self.segment_count_length.write_xdr(w)?; + self.fingerprint_length.write_xdr(w)?; + self.fingerprints.write_xdr(w)?; + Ok(()) + }) + } +} + #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)] #[cfg_attr( all(feature = "serde", feature = "alloc"), @@ -44799,10 +45035,13 @@ pub enum TypeVariant { Curve25519Public, HmacSha256Key, HmacSha256Mac, + ShortHashSeed, + BinaryFuseFilterType, + SerializedBinaryFuseFilter, } impl TypeVariant { - pub const VARIANTS: [TypeVariant; 438] = [ + pub const VARIANTS: [TypeVariant; 441] = [ TypeVariant::Value, TypeVariant::ScpBallot, TypeVariant::ScpStatementType, @@ -45241,8 +45480,11 @@ impl TypeVariant { TypeVariant::Curve25519Public, TypeVariant::HmacSha256Key, TypeVariant::HmacSha256Mac, + TypeVariant::ShortHashSeed, + TypeVariant::BinaryFuseFilterType, + TypeVariant::SerializedBinaryFuseFilter, ]; - pub const VARIANTS_STR: [&'static str; 438] = [ + pub const VARIANTS_STR: [&'static str; 441] = [ "Value", "ScpBallot", "ScpStatementType", @@ -45681,6 +45923,9 @@ impl TypeVariant { "Curve25519Public", "HmacSha256Key", "HmacSha256Mac", + "ShortHashSeed", + "BinaryFuseFilterType", + "SerializedBinaryFuseFilter", ]; #[must_use] @@ -46137,12 +46382,15 @@ impl TypeVariant { Self::Curve25519Public => "Curve25519Public", Self::HmacSha256Key => "HmacSha256Key", Self::HmacSha256Mac => "HmacSha256Mac", + Self::ShortHashSeed => "ShortHashSeed", + Self::BinaryFuseFilterType => "BinaryFuseFilterType", + Self::SerializedBinaryFuseFilter => "SerializedBinaryFuseFilter", } } #[must_use] #[allow(clippy::too_many_lines)] - pub const fn variants() -> [TypeVariant; 438] { + pub const fn variants() -> [TypeVariant; 441] { Self::VARIANTS } @@ -46789,6 +47037,11 @@ impl TypeVariant { Self::Curve25519Public => gen.into_root_schema_for::(), Self::HmacSha256Key => gen.into_root_schema_for::(), Self::HmacSha256Mac => gen.into_root_schema_for::(), + Self::ShortHashSeed => gen.into_root_schema_for::(), + Self::BinaryFuseFilterType => gen.into_root_schema_for::(), + Self::SerializedBinaryFuseFilter => { + gen.into_root_schema_for::() + } } } } @@ -47275,6 +47528,9 @@ impl core::str::FromStr for TypeVariant { "Curve25519Public" => Ok(Self::Curve25519Public), "HmacSha256Key" => Ok(Self::HmacSha256Key), "HmacSha256Mac" => Ok(Self::HmacSha256Mac), + "ShortHashSeed" => Ok(Self::ShortHashSeed), + "BinaryFuseFilterType" => Ok(Self::BinaryFuseFilterType), + "SerializedBinaryFuseFilter" => Ok(Self::SerializedBinaryFuseFilter), _ => Err(Error::Invalid), } } @@ -47727,10 +47983,13 @@ pub enum Type { Curve25519Public(Box), HmacSha256Key(Box), HmacSha256Mac(Box), + ShortHashSeed(Box), + BinaryFuseFilterType(Box), + SerializedBinaryFuseFilter(Box), } impl Type { - pub const VARIANTS: [TypeVariant; 438] = [ + pub const VARIANTS: [TypeVariant; 441] = [ TypeVariant::Value, TypeVariant::ScpBallot, TypeVariant::ScpStatementType, @@ -48169,8 +48428,11 @@ impl Type { TypeVariant::Curve25519Public, TypeVariant::HmacSha256Key, TypeVariant::HmacSha256Mac, + TypeVariant::ShortHashSeed, + TypeVariant::BinaryFuseFilterType, + TypeVariant::SerializedBinaryFuseFilter, ]; - pub const VARIANTS_STR: [&'static str; 438] = [ + pub const VARIANTS_STR: [&'static str; 441] = [ "Value", "ScpBallot", "ScpStatementType", @@ -48609,6 +48871,9 @@ impl Type { "Curve25519Public", "HmacSha256Key", "HmacSha256Mac", + "ShortHashSeed", + "BinaryFuseFilterType", + "SerializedBinaryFuseFilter", ]; #[cfg(feature = "std")] @@ -50515,6 +50780,19 @@ impl Type { TypeVariant::HmacSha256Mac => r.with_limited_depth(|r| { Ok(Self::HmacSha256Mac(Box::new(HmacSha256Mac::read_xdr(r)?))) }), + TypeVariant::ShortHashSeed => r.with_limited_depth(|r| { + Ok(Self::ShortHashSeed(Box::new(ShortHashSeed::read_xdr(r)?))) + }), + TypeVariant::BinaryFuseFilterType => r.with_limited_depth(|r| { + Ok(Self::BinaryFuseFilterType(Box::new( + BinaryFuseFilterType::read_xdr(r)?, + ))) + }), + TypeVariant::SerializedBinaryFuseFilter => r.with_limited_depth(|r| { + Ok(Self::SerializedBinaryFuseFilter(Box::new( + SerializedBinaryFuseFilter::read_xdr(r)?, + ))) + }), } } @@ -52445,6 +52723,18 @@ impl Type { ReadXdrIter::<_, HmacSha256Mac>::new(&mut r.inner, r.limits.clone()) .map(|r| r.map(|t| Self::HmacSha256Mac(Box::new(t)))), ), + TypeVariant::ShortHashSeed => Box::new( + ReadXdrIter::<_, ShortHashSeed>::new(&mut r.inner, r.limits.clone()) + .map(|r| r.map(|t| Self::ShortHashSeed(Box::new(t)))), + ), + TypeVariant::BinaryFuseFilterType => Box::new( + ReadXdrIter::<_, BinaryFuseFilterType>::new(&mut r.inner, r.limits.clone()) + .map(|r| r.map(|t| Self::BinaryFuseFilterType(Box::new(t)))), + ), + TypeVariant::SerializedBinaryFuseFilter => Box::new( + ReadXdrIter::<_, SerializedBinaryFuseFilter>::new(&mut r.inner, r.limits.clone()) + .map(|r| r.map(|t| Self::SerializedBinaryFuseFilter(Box::new(t)))), + ), } } @@ -54630,6 +54920,21 @@ impl Type { ReadXdrIter::<_, Frame>::new(&mut r.inner, r.limits.clone()) .map(|r| r.map(|t| Self::HmacSha256Mac(Box::new(t.0)))), ), + TypeVariant::ShortHashSeed => Box::new( + ReadXdrIter::<_, Frame>::new(&mut r.inner, r.limits.clone()) + .map(|r| r.map(|t| Self::ShortHashSeed(Box::new(t.0)))), + ), + TypeVariant::BinaryFuseFilterType => Box::new( + ReadXdrIter::<_, Frame>::new(&mut r.inner, r.limits.clone()) + .map(|r| r.map(|t| Self::BinaryFuseFilterType(Box::new(t.0)))), + ), + TypeVariant::SerializedBinaryFuseFilter => Box::new( + ReadXdrIter::<_, Frame>::new( + &mut r.inner, + r.limits.clone(), + ) + .map(|r| r.map(|t| Self::SerializedBinaryFuseFilter(Box::new(t.0)))), + ), } } @@ -56415,6 +56720,18 @@ impl Type { ReadXdrIter::<_, HmacSha256Mac>::new(dec, r.limits.clone()) .map(|r| r.map(|t| Self::HmacSha256Mac(Box::new(t)))), ), + TypeVariant::ShortHashSeed => Box::new( + ReadXdrIter::<_, ShortHashSeed>::new(dec, r.limits.clone()) + .map(|r| r.map(|t| Self::ShortHashSeed(Box::new(t)))), + ), + TypeVariant::BinaryFuseFilterType => Box::new( + ReadXdrIter::<_, BinaryFuseFilterType>::new(dec, r.limits.clone()) + .map(|r| r.map(|t| Self::BinaryFuseFilterType(Box::new(t)))), + ), + TypeVariant::SerializedBinaryFuseFilter => Box::new( + ReadXdrIter::<_, SerializedBinaryFuseFilter>::new(dec, r.limits.clone()) + .map(|r| r.map(|t| Self::SerializedBinaryFuseFilter(Box::new(t)))), + ), } } @@ -57634,6 +57951,15 @@ impl Type { TypeVariant::HmacSha256Mac => { Ok(Self::HmacSha256Mac(Box::new(serde_json::from_reader(r)?))) } + TypeVariant::ShortHashSeed => { + Ok(Self::ShortHashSeed(Box::new(serde_json::from_reader(r)?))) + } + TypeVariant::BinaryFuseFilterType => Ok(Self::BinaryFuseFilterType(Box::new( + serde_json::from_reader(r)?, + ))), + TypeVariant::SerializedBinaryFuseFilter => Ok(Self::SerializedBinaryFuseFilter( + Box::new(serde_json::from_reader(r)?), + )), } } @@ -58081,6 +58407,9 @@ impl Type { Self::Curve25519Public(ref v) => v.as_ref(), Self::HmacSha256Key(ref v) => v.as_ref(), Self::HmacSha256Mac(ref v) => v.as_ref(), + Self::ShortHashSeed(ref v) => v.as_ref(), + Self::BinaryFuseFilterType(ref v) => v.as_ref(), + Self::SerializedBinaryFuseFilter(ref v) => v.as_ref(), } } @@ -58550,12 +58879,15 @@ impl Type { Self::Curve25519Public(_) => "Curve25519Public", Self::HmacSha256Key(_) => "HmacSha256Key", Self::HmacSha256Mac(_) => "HmacSha256Mac", + Self::ShortHashSeed(_) => "ShortHashSeed", + Self::BinaryFuseFilterType(_) => "BinaryFuseFilterType", + Self::SerializedBinaryFuseFilter(_) => "SerializedBinaryFuseFilter", } } #[must_use] #[allow(clippy::too_many_lines)] - pub const fn variants() -> [TypeVariant; 438] { + pub const fn variants() -> [TypeVariant; 441] { Self::VARIANTS } @@ -59067,6 +59399,9 @@ impl Type { Self::Curve25519Public(_) => TypeVariant::Curve25519Public, Self::HmacSha256Key(_) => TypeVariant::HmacSha256Key, Self::HmacSha256Mac(_) => TypeVariant::HmacSha256Mac, + Self::ShortHashSeed(_) => TypeVariant::ShortHashSeed, + Self::BinaryFuseFilterType(_) => TypeVariant::BinaryFuseFilterType, + Self::SerializedBinaryFuseFilter(_) => TypeVariant::SerializedBinaryFuseFilter, } } } @@ -59527,6 +59862,9 @@ impl WriteXdr for Type { Self::Curve25519Public(v) => v.write_xdr(w), Self::HmacSha256Key(v) => v.write_xdr(w), Self::HmacSha256Mac(v) => v.write_xdr(w), + Self::ShortHashSeed(v) => v.write_xdr(w), + Self::BinaryFuseFilterType(v) => v.write_xdr(w), + Self::SerializedBinaryFuseFilter(v) => v.write_xdr(w), } } } diff --git a/src/next/generated.rs b/src/next/generated.rs index 2094fb81..77350fd2 100644 --- a/src/next/generated.rs +++ b/src/next/generated.rs @@ -22,7 +22,7 @@ pub const XDR_FILES_SHA256: [(&str, &str); 12] = [ ), ( "xdr/next/Stellar-contract-config-setting.x", - "393369678663cb0f9471a0b69e2a9cfa3ac93c4415fa40cec166e9a231ecbe0d", + "c92782d7c6d6f0ea0b2148cabc66c557f38cb23714257f2131235a88f4282366", ), ( "xdr/next/Stellar-contract-env-meta.x", @@ -50,7 +50,7 @@ pub const XDR_FILES_SHA256: [(&str, &str); 12] = [ ), ( "xdr/next/Stellar-ledger.x", - "888152fb940b79a01ac00a5218ca91360cb0f01af7acc030d5805ebfec280203", + "3f9f0ad62cdd34390cf0cbe16e3266374c061b5f5abbe8fbe1396de32bcc23eb", ), ( "xdr/next/Stellar-overlay.x", @@ -62,7 +62,7 @@ pub const XDR_FILES_SHA256: [(&str, &str); 12] = [ ), ( "xdr/next/Stellar-types.x", - "6e3b13f0d3e360b09fa5e2b0e55d43f4d974a769df66afb34e8aecbb329d3f15", + "afe02efc4e6767ed8909c3b4350c4045449b614ce487adcf7e9f816f309bf6f8", ), ]; @@ -3757,6 +3757,54 @@ impl WriteXdr for ConfigSettingContractComputeV0 { } } +/// ConfigSettingContractParallelComputeV0 is an XDR Struct defines as: +/// +/// ```text +/// struct ConfigSettingContractParallelComputeV0 +/// { +/// // Maximum number of threads that can be used to apply a +/// // transaction set to close the ledger. +/// // This doesn't limit or defined the actual number of +/// // threads used and instead only defines the minimum number +/// // of physical threads that a tier-1 validator has to support +/// // in order to not fall out of sync with the network. +/// uint32 ledgerMaxParallelThreads; +/// }; +/// ``` +/// +#[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)] +#[cfg_attr(feature = "arbitrary", derive(Arbitrary))] +#[cfg_attr( + all(feature = "serde", feature = "alloc"), + derive(serde::Serialize, serde::Deserialize), + serde(rename_all = "snake_case") +)] +#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))] +pub struct ConfigSettingContractParallelComputeV0 { + pub ledger_max_parallel_threads: u32, +} + +impl ReadXdr for ConfigSettingContractParallelComputeV0 { + #[cfg(feature = "std")] + fn read_xdr(r: &mut Limited) -> Result { + r.with_limited_depth(|r| { + Ok(Self { + ledger_max_parallel_threads: u32::read_xdr(r)?, + }) + }) + } +} + +impl WriteXdr for ConfigSettingContractParallelComputeV0 { + #[cfg(feature = "std")] + fn write_xdr(&self, w: &mut Limited) -> Result<()> { + w.with_limited_depth(|w| { + self.ledger_max_parallel_threads.write_xdr(w)?; + Ok(()) + }) + } +} + /// ConfigSettingContractLedgerCostV0 is an XDR Struct defines as: /// /// ```text @@ -4760,7 +4808,8 @@ impl AsRef<[ContractCostParamEntry]> for ContractCostParams { /// CONFIG_SETTING_STATE_ARCHIVAL = 10, /// CONFIG_SETTING_CONTRACT_EXECUTION_LANES = 11, /// CONFIG_SETTING_BUCKETLIST_SIZE_WINDOW = 12, -/// CONFIG_SETTING_EVICTION_ITERATOR = 13 +/// CONFIG_SETTING_EVICTION_ITERATOR = 13, +/// CONFIG_SETTING_CONTRACT_PARALLEL_COMPUTE_V0 = 14 /// }; /// ``` /// @@ -4789,10 +4838,11 @@ pub enum ConfigSettingId { ContractExecutionLanes = 11, BucketlistSizeWindow = 12, EvictionIterator = 13, + ContractParallelComputeV0 = 14, } impl ConfigSettingId { - pub const VARIANTS: [ConfigSettingId; 14] = [ + pub const VARIANTS: [ConfigSettingId; 15] = [ ConfigSettingId::ContractMaxSizeBytes, ConfigSettingId::ContractComputeV0, ConfigSettingId::ContractLedgerCostV0, @@ -4807,8 +4857,9 @@ impl ConfigSettingId { ConfigSettingId::ContractExecutionLanes, ConfigSettingId::BucketlistSizeWindow, ConfigSettingId::EvictionIterator, + ConfigSettingId::ContractParallelComputeV0, ]; - pub const VARIANTS_STR: [&'static str; 14] = [ + pub const VARIANTS_STR: [&'static str; 15] = [ "ContractMaxSizeBytes", "ContractComputeV0", "ContractLedgerCostV0", @@ -4823,6 +4874,7 @@ impl ConfigSettingId { "ContractExecutionLanes", "BucketlistSizeWindow", "EvictionIterator", + "ContractParallelComputeV0", ]; #[must_use] @@ -4842,11 +4894,12 @@ impl ConfigSettingId { Self::ContractExecutionLanes => "ContractExecutionLanes", Self::BucketlistSizeWindow => "BucketlistSizeWindow", Self::EvictionIterator => "EvictionIterator", + Self::ContractParallelComputeV0 => "ContractParallelComputeV0", } } #[must_use] - pub const fn variants() -> [ConfigSettingId; 14] { + pub const fn variants() -> [ConfigSettingId; 15] { Self::VARIANTS } } @@ -4891,6 +4944,7 @@ impl TryFrom for ConfigSettingId { 11 => ConfigSettingId::ContractExecutionLanes, 12 => ConfigSettingId::BucketlistSizeWindow, 13 => ConfigSettingId::EvictionIterator, + 14 => ConfigSettingId::ContractParallelComputeV0, #[allow(unreachable_patterns)] _ => return Err(Error::Invalid), }; @@ -4959,6 +5013,8 @@ impl WriteXdr for ConfigSettingId { /// uint64 bucketListSizeWindow<>; /// case CONFIG_SETTING_EVICTION_ITERATOR: /// EvictionIterator evictionIterator; +/// case CONFIG_SETTING_CONTRACT_PARALLEL_COMPUTE_V0: +/// ConfigSettingContractParallelComputeV0 contractParallelCompute; /// }; /// ``` /// @@ -4987,10 +5043,11 @@ pub enum ConfigSettingEntry { ContractExecutionLanes(ConfigSettingContractExecutionLanesV0), BucketlistSizeWindow(VecM), EvictionIterator(EvictionIterator), + ContractParallelComputeV0(ConfigSettingContractParallelComputeV0), } impl ConfigSettingEntry { - pub const VARIANTS: [ConfigSettingId; 14] = [ + pub const VARIANTS: [ConfigSettingId; 15] = [ ConfigSettingId::ContractMaxSizeBytes, ConfigSettingId::ContractComputeV0, ConfigSettingId::ContractLedgerCostV0, @@ -5005,8 +5062,9 @@ impl ConfigSettingEntry { ConfigSettingId::ContractExecutionLanes, ConfigSettingId::BucketlistSizeWindow, ConfigSettingId::EvictionIterator, + ConfigSettingId::ContractParallelComputeV0, ]; - pub const VARIANTS_STR: [&'static str; 14] = [ + pub const VARIANTS_STR: [&'static str; 15] = [ "ContractMaxSizeBytes", "ContractComputeV0", "ContractLedgerCostV0", @@ -5021,6 +5079,7 @@ impl ConfigSettingEntry { "ContractExecutionLanes", "BucketlistSizeWindow", "EvictionIterator", + "ContractParallelComputeV0", ]; #[must_use] @@ -5040,6 +5099,7 @@ impl ConfigSettingEntry { Self::ContractExecutionLanes(_) => "ContractExecutionLanes", Self::BucketlistSizeWindow(_) => "BucketlistSizeWindow", Self::EvictionIterator(_) => "EvictionIterator", + Self::ContractParallelComputeV0(_) => "ContractParallelComputeV0", } } @@ -5065,11 +5125,12 @@ impl ConfigSettingEntry { Self::ContractExecutionLanes(_) => ConfigSettingId::ContractExecutionLanes, Self::BucketlistSizeWindow(_) => ConfigSettingId::BucketlistSizeWindow, Self::EvictionIterator(_) => ConfigSettingId::EvictionIterator, + Self::ContractParallelComputeV0(_) => ConfigSettingId::ContractParallelComputeV0, } } #[must_use] - pub const fn variants() -> [ConfigSettingId; 14] { + pub const fn variants() -> [ConfigSettingId; 15] { Self::VARIANTS } } @@ -5145,6 +5206,9 @@ impl ReadXdr for ConfigSettingEntry { ConfigSettingId::EvictionIterator => { Self::EvictionIterator(EvictionIterator::read_xdr(r)?) } + ConfigSettingId::ContractParallelComputeV0 => Self::ContractParallelComputeV0( + ConfigSettingContractParallelComputeV0::read_xdr(r)?, + ), #[allow(unreachable_patterns)] _ => return Err(Error::Invalid), }; @@ -5174,6 +5238,7 @@ impl WriteXdr for ConfigSettingEntry { Self::ContractExecutionLanes(v) => v.write_xdr(w)?, Self::BucketlistSizeWindow(v) => v.write_xdr(w)?, Self::EvictionIterator(v) => v.write_xdr(w)?, + Self::ContractParallelComputeV0(v) => v.write_xdr(w)?, }; Ok(()) }) @@ -19300,6 +19365,264 @@ impl WriteXdr for TxSetComponentType { } } +/// TxExecutionThread is an XDR Typedef defines as: +/// +/// ```text +/// typedef TransactionEnvelope TxExecutionThread<>; +/// ``` +/// +#[derive(Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] +#[cfg_attr(feature = "arbitrary", derive(Arbitrary))] +#[derive(Default)] +#[cfg_attr( + all(feature = "serde", feature = "alloc"), + derive(serde::Serialize, serde::Deserialize), + serde(rename_all = "snake_case") +)] +#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))] +#[derive(Debug)] +pub struct TxExecutionThread(pub VecM); + +impl From for VecM { + #[must_use] + fn from(x: TxExecutionThread) -> Self { + x.0 + } +} + +impl From> for TxExecutionThread { + #[must_use] + fn from(x: VecM) -> Self { + TxExecutionThread(x) + } +} + +impl AsRef> for TxExecutionThread { + #[must_use] + fn as_ref(&self) -> &VecM { + &self.0 + } +} + +impl ReadXdr for TxExecutionThread { + #[cfg(feature = "std")] + fn read_xdr(r: &mut Limited) -> Result { + r.with_limited_depth(|r| { + let i = VecM::::read_xdr(r)?; + let v = TxExecutionThread(i); + Ok(v) + }) + } +} + +impl WriteXdr for TxExecutionThread { + #[cfg(feature = "std")] + fn write_xdr(&self, w: &mut Limited) -> Result<()> { + w.with_limited_depth(|w| self.0.write_xdr(w)) + } +} + +impl Deref for TxExecutionThread { + type Target = VecM; + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +impl From for Vec { + #[must_use] + fn from(x: TxExecutionThread) -> Self { + x.0 .0 + } +} + +impl TryFrom> for TxExecutionThread { + type Error = Error; + fn try_from(x: Vec) -> Result { + Ok(TxExecutionThread(x.try_into()?)) + } +} + +#[cfg(feature = "alloc")] +impl TryFrom<&Vec> for TxExecutionThread { + type Error = Error; + fn try_from(x: &Vec) -> Result { + Ok(TxExecutionThread(x.try_into()?)) + } +} + +impl AsRef> for TxExecutionThread { + #[must_use] + fn as_ref(&self) -> &Vec { + &self.0 .0 + } +} + +impl AsRef<[TransactionEnvelope]> for TxExecutionThread { + #[cfg(feature = "alloc")] + #[must_use] + fn as_ref(&self) -> &[TransactionEnvelope] { + &self.0 .0 + } + #[cfg(not(feature = "alloc"))] + #[must_use] + fn as_ref(&self) -> &[TransactionEnvelope] { + self.0 .0 + } +} + +/// ParallelTxExecutionStage is an XDR Typedef defines as: +/// +/// ```text +/// typedef TxExecutionThread ParallelTxExecutionStage<>; +/// ``` +/// +#[derive(Clone, Hash, PartialEq, Eq, PartialOrd, Ord)] +#[cfg_attr(feature = "arbitrary", derive(Arbitrary))] +#[derive(Default)] +#[cfg_attr( + all(feature = "serde", feature = "alloc"), + derive(serde::Serialize, serde::Deserialize), + serde(rename_all = "snake_case") +)] +#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))] +#[derive(Debug)] +pub struct ParallelTxExecutionStage(pub VecM); + +impl From for VecM { + #[must_use] + fn from(x: ParallelTxExecutionStage) -> Self { + x.0 + } +} + +impl From> for ParallelTxExecutionStage { + #[must_use] + fn from(x: VecM) -> Self { + ParallelTxExecutionStage(x) + } +} + +impl AsRef> for ParallelTxExecutionStage { + #[must_use] + fn as_ref(&self) -> &VecM { + &self.0 + } +} + +impl ReadXdr for ParallelTxExecutionStage { + #[cfg(feature = "std")] + fn read_xdr(r: &mut Limited) -> Result { + r.with_limited_depth(|r| { + let i = VecM::::read_xdr(r)?; + let v = ParallelTxExecutionStage(i); + Ok(v) + }) + } +} + +impl WriteXdr for ParallelTxExecutionStage { + #[cfg(feature = "std")] + fn write_xdr(&self, w: &mut Limited) -> Result<()> { + w.with_limited_depth(|w| self.0.write_xdr(w)) + } +} + +impl Deref for ParallelTxExecutionStage { + type Target = VecM; + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +impl From for Vec { + #[must_use] + fn from(x: ParallelTxExecutionStage) -> Self { + x.0 .0 + } +} + +impl TryFrom> for ParallelTxExecutionStage { + type Error = Error; + fn try_from(x: Vec) -> Result { + Ok(ParallelTxExecutionStage(x.try_into()?)) + } +} + +#[cfg(feature = "alloc")] +impl TryFrom<&Vec> for ParallelTxExecutionStage { + type Error = Error; + fn try_from(x: &Vec) -> Result { + Ok(ParallelTxExecutionStage(x.try_into()?)) + } +} + +impl AsRef> for ParallelTxExecutionStage { + #[must_use] + fn as_ref(&self) -> &Vec { + &self.0 .0 + } +} + +impl AsRef<[TxExecutionThread]> for ParallelTxExecutionStage { + #[cfg(feature = "alloc")] + #[must_use] + fn as_ref(&self) -> &[TxExecutionThread] { + &self.0 .0 + } + #[cfg(not(feature = "alloc"))] + #[must_use] + fn as_ref(&self) -> &[TxExecutionThread] { + self.0 .0 + } +} + +/// ParallelTxsComponent is an XDR Struct defines as: +/// +/// ```text +/// struct ParallelTxsComponent +/// { +/// int64* baseFee; +/// ParallelTxExecutionStage executionStages<>; +/// }; +/// ``` +/// +#[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)] +#[cfg_attr(feature = "arbitrary", derive(Arbitrary))] +#[cfg_attr( + all(feature = "serde", feature = "alloc"), + derive(serde::Serialize, serde::Deserialize), + serde(rename_all = "snake_case") +)] +#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))] +pub struct ParallelTxsComponent { + pub base_fee: Option, + pub execution_stages: VecM, +} + +impl ReadXdr for ParallelTxsComponent { + #[cfg(feature = "std")] + fn read_xdr(r: &mut Limited) -> Result { + r.with_limited_depth(|r| { + Ok(Self { + base_fee: Option::::read_xdr(r)?, + execution_stages: VecM::::read_xdr(r)?, + }) + }) + } +} + +impl WriteXdr for ParallelTxsComponent { + #[cfg(feature = "std")] + fn write_xdr(&self, w: &mut Limited) -> Result<()> { + w.with_limited_depth(|w| { + self.base_fee.write_xdr(w)?; + self.execution_stages.write_xdr(w)?; + Ok(()) + }) + } +} + /// TxSetComponentTxsMaybeDiscountedFee is an XDR NestedStruct defines as: /// /// ```text @@ -19465,6 +19788,8 @@ impl WriteXdr for TxSetComponent { /// { /// case 0: /// TxSetComponent v0Components<>; +/// case 1: +/// ParallelTxsComponent parallelTxsComponent; /// }; /// ``` /// @@ -19480,16 +19805,18 @@ impl WriteXdr for TxSetComponent { #[allow(clippy::large_enum_variant)] pub enum TransactionPhase { V0(VecM), + V1(ParallelTxsComponent), } impl TransactionPhase { - pub const VARIANTS: [i32; 1] = [0]; - pub const VARIANTS_STR: [&'static str; 1] = ["V0"]; + pub const VARIANTS: [i32; 2] = [0, 1]; + pub const VARIANTS_STR: [&'static str; 2] = ["V0", "V1"]; #[must_use] pub const fn name(&self) -> &'static str { match self { Self::V0(_) => "V0", + Self::V1(_) => "V1", } } @@ -19498,11 +19825,12 @@ impl TransactionPhase { #[allow(clippy::match_same_arms)] match self { Self::V0(_) => 0, + Self::V1(_) => 1, } } #[must_use] - pub const fn variants() -> [i32; 1] { + pub const fn variants() -> [i32; 2] { Self::VARIANTS } } @@ -19537,6 +19865,7 @@ impl ReadXdr for TransactionPhase { #[allow(clippy::match_same_arms, clippy::match_wildcard_for_single_variants)] let v = match dv { 0 => Self::V0(VecM::::read_xdr(r)?), + 1 => Self::V1(ParallelTxsComponent::read_xdr(r)?), #[allow(unreachable_patterns)] _ => return Err(Error::Invalid), }; @@ -19553,6 +19882,7 @@ impl WriteXdr for TransactionPhase { #[allow(clippy::match_same_arms)] match self { Self::V0(v) => v.write_xdr(w)?, + Self::V1(v) => v.write_xdr(w)?, }; Ok(()) }) @@ -44247,6 +44577,242 @@ impl WriteXdr for HmacSha256Mac { } } +/// ShortHashSeed is an XDR Struct defines as: +/// +/// ```text +/// struct ShortHashSeed +/// { +/// opaque seed[16]; +/// }; +/// ``` +/// +#[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)] +#[cfg_attr(feature = "arbitrary", derive(Arbitrary))] +#[cfg_attr( + all(feature = "serde", feature = "alloc"), + derive(serde::Serialize, serde::Deserialize), + serde(rename_all = "snake_case") +)] +#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))] +pub struct ShortHashSeed { + pub seed: [u8; 16], +} + +impl ReadXdr for ShortHashSeed { + #[cfg(feature = "std")] + fn read_xdr(r: &mut Limited) -> Result { + r.with_limited_depth(|r| { + Ok(Self { + seed: <[u8; 16]>::read_xdr(r)?, + }) + }) + } +} + +impl WriteXdr for ShortHashSeed { + #[cfg(feature = "std")] + fn write_xdr(&self, w: &mut Limited) -> Result<()> { + w.with_limited_depth(|w| { + self.seed.write_xdr(w)?; + Ok(()) + }) + } +} + +/// BinaryFuseFilterType is an XDR Enum defines as: +/// +/// ```text +/// enum BinaryFuseFilterType +/// { +/// BINARY_FUSE_FILTER_8_BIT = 0, +/// BINARY_FUSE_FILTER_16_BIT = 1, +/// BINARY_FUSE_FILTER_32_BIT = 2 +/// }; +/// ``` +/// +// enum +#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)] +#[cfg_attr(feature = "arbitrary", derive(Arbitrary))] +#[cfg_attr( + all(feature = "serde", feature = "alloc"), + derive(serde::Serialize, serde::Deserialize), + serde(rename_all = "snake_case") +)] +#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))] +#[repr(i32)] +pub enum BinaryFuseFilterType { + B8Bit = 0, + B16Bit = 1, + B32Bit = 2, +} + +impl BinaryFuseFilterType { + pub const VARIANTS: [BinaryFuseFilterType; 3] = [ + BinaryFuseFilterType::B8Bit, + BinaryFuseFilterType::B16Bit, + BinaryFuseFilterType::B32Bit, + ]; + pub const VARIANTS_STR: [&'static str; 3] = ["B8Bit", "B16Bit", "B32Bit"]; + + #[must_use] + pub const fn name(&self) -> &'static str { + match self { + Self::B8Bit => "B8Bit", + Self::B16Bit => "B16Bit", + Self::B32Bit => "B32Bit", + } + } + + #[must_use] + pub const fn variants() -> [BinaryFuseFilterType; 3] { + Self::VARIANTS + } +} + +impl Name for BinaryFuseFilterType { + #[must_use] + fn name(&self) -> &'static str { + Self::name(self) + } +} + +impl Variants for BinaryFuseFilterType { + fn variants() -> slice::Iter<'static, BinaryFuseFilterType> { + Self::VARIANTS.iter() + } +} + +impl Enum for BinaryFuseFilterType {} + +impl fmt::Display for BinaryFuseFilterType { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str(self.name()) + } +} + +impl TryFrom for BinaryFuseFilterType { + type Error = Error; + + fn try_from(i: i32) -> Result { + let e = match i { + 0 => BinaryFuseFilterType::B8Bit, + 1 => BinaryFuseFilterType::B16Bit, + 2 => BinaryFuseFilterType::B32Bit, + #[allow(unreachable_patterns)] + _ => return Err(Error::Invalid), + }; + Ok(e) + } +} + +impl From for i32 { + #[must_use] + fn from(e: BinaryFuseFilterType) -> Self { + e as Self + } +} + +impl ReadXdr for BinaryFuseFilterType { + #[cfg(feature = "std")] + fn read_xdr(r: &mut Limited) -> Result { + r.with_limited_depth(|r| { + let e = i32::read_xdr(r)?; + let v: Self = e.try_into()?; + Ok(v) + }) + } +} + +impl WriteXdr for BinaryFuseFilterType { + #[cfg(feature = "std")] + fn write_xdr(&self, w: &mut Limited) -> Result<()> { + w.with_limited_depth(|w| { + let i: i32 = (*self).into(); + i.write_xdr(w) + }) + } +} + +/// SerializedBinaryFuseFilter is an XDR Struct defines as: +/// +/// ```text +/// struct SerializedBinaryFuseFilter +/// { +/// BinaryFuseFilterType type; +/// +/// // Seed used to hash input to filter +/// ShortHashSeed inputHashSeed; +/// +/// // Seed used for internal filter hash operations +/// ShortHashSeed filterSeed; +/// uint32 segmentLength; +/// uint32 segementLengthMask; +/// uint32 segmentCount; +/// uint32 segmentCountLength; +/// uint32 fingerprintLength; // Length in terms of element count, not bytes +/// +/// // Array of uint8_t, uint16_t, or uint32_t depending on filter type +/// opaque fingerprints<>; +/// }; +/// ``` +/// +#[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)] +#[cfg_attr(feature = "arbitrary", derive(Arbitrary))] +#[cfg_attr( + all(feature = "serde", feature = "alloc"), + derive(serde::Serialize, serde::Deserialize), + serde(rename_all = "snake_case") +)] +#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))] +pub struct SerializedBinaryFuseFilter { + pub type_: BinaryFuseFilterType, + pub input_hash_seed: ShortHashSeed, + pub filter_seed: ShortHashSeed, + pub segment_length: u32, + pub segement_length_mask: u32, + pub segment_count: u32, + pub segment_count_length: u32, + pub fingerprint_length: u32, + pub fingerprints: BytesM, +} + +impl ReadXdr for SerializedBinaryFuseFilter { + #[cfg(feature = "std")] + fn read_xdr(r: &mut Limited) -> Result { + r.with_limited_depth(|r| { + Ok(Self { + type_: BinaryFuseFilterType::read_xdr(r)?, + input_hash_seed: ShortHashSeed::read_xdr(r)?, + filter_seed: ShortHashSeed::read_xdr(r)?, + segment_length: u32::read_xdr(r)?, + segement_length_mask: u32::read_xdr(r)?, + segment_count: u32::read_xdr(r)?, + segment_count_length: u32::read_xdr(r)?, + fingerprint_length: u32::read_xdr(r)?, + fingerprints: BytesM::read_xdr(r)?, + }) + }) + } +} + +impl WriteXdr for SerializedBinaryFuseFilter { + #[cfg(feature = "std")] + fn write_xdr(&self, w: &mut Limited) -> Result<()> { + w.with_limited_depth(|w| { + self.type_.write_xdr(w)?; + self.input_hash_seed.write_xdr(w)?; + self.filter_seed.write_xdr(w)?; + self.segment_length.write_xdr(w)?; + self.segement_length_mask.write_xdr(w)?; + self.segment_count.write_xdr(w)?; + self.segment_count_length.write_xdr(w)?; + self.fingerprint_length.write_xdr(w)?; + self.fingerprints.write_xdr(w)?; + Ok(()) + }) + } +} + #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)] #[cfg_attr( all(feature = "serde", feature = "alloc"), @@ -44268,6 +44834,7 @@ pub enum TypeVariant { ScpQuorumSet, ConfigSettingContractExecutionLanesV0, ConfigSettingContractComputeV0, + ConfigSettingContractParallelComputeV0, ConfigSettingContractLedgerCostV0, ConfigSettingContractHistoricalDataV0, ConfigSettingContractEventsV0, @@ -44434,6 +45001,9 @@ pub enum TypeVariant { BucketMetadataExt, BucketEntry, TxSetComponentType, + TxExecutionThread, + ParallelTxExecutionStage, + ParallelTxsComponent, TxSetComponent, TxSetComponentTxsMaybeDiscountedFee, TransactionPhase, @@ -44692,10 +45262,13 @@ pub enum TypeVariant { Curve25519Public, HmacSha256Key, HmacSha256Mac, + ShortHashSeed, + BinaryFuseFilterType, + SerializedBinaryFuseFilter, } impl TypeVariant { - pub const VARIANTS: [TypeVariant; 437] = [ + pub const VARIANTS: [TypeVariant; 444] = [ TypeVariant::Value, TypeVariant::ScpBallot, TypeVariant::ScpStatementType, @@ -44709,6 +45282,7 @@ impl TypeVariant { TypeVariant::ScpQuorumSet, TypeVariant::ConfigSettingContractExecutionLanesV0, TypeVariant::ConfigSettingContractComputeV0, + TypeVariant::ConfigSettingContractParallelComputeV0, TypeVariant::ConfigSettingContractLedgerCostV0, TypeVariant::ConfigSettingContractHistoricalDataV0, TypeVariant::ConfigSettingContractEventsV0, @@ -44875,6 +45449,9 @@ impl TypeVariant { TypeVariant::BucketMetadataExt, TypeVariant::BucketEntry, TypeVariant::TxSetComponentType, + TypeVariant::TxExecutionThread, + TypeVariant::ParallelTxExecutionStage, + TypeVariant::ParallelTxsComponent, TypeVariant::TxSetComponent, TypeVariant::TxSetComponentTxsMaybeDiscountedFee, TypeVariant::TransactionPhase, @@ -45133,8 +45710,11 @@ impl TypeVariant { TypeVariant::Curve25519Public, TypeVariant::HmacSha256Key, TypeVariant::HmacSha256Mac, + TypeVariant::ShortHashSeed, + TypeVariant::BinaryFuseFilterType, + TypeVariant::SerializedBinaryFuseFilter, ]; - pub const VARIANTS_STR: [&'static str; 437] = [ + pub const VARIANTS_STR: [&'static str; 444] = [ "Value", "ScpBallot", "ScpStatementType", @@ -45148,6 +45728,7 @@ impl TypeVariant { "ScpQuorumSet", "ConfigSettingContractExecutionLanesV0", "ConfigSettingContractComputeV0", + "ConfigSettingContractParallelComputeV0", "ConfigSettingContractLedgerCostV0", "ConfigSettingContractHistoricalDataV0", "ConfigSettingContractEventsV0", @@ -45314,6 +45895,9 @@ impl TypeVariant { "BucketMetadataExt", "BucketEntry", "TxSetComponentType", + "TxExecutionThread", + "ParallelTxExecutionStage", + "ParallelTxsComponent", "TxSetComponent", "TxSetComponentTxsMaybeDiscountedFee", "TransactionPhase", @@ -45572,6 +46156,9 @@ impl TypeVariant { "Curve25519Public", "HmacSha256Key", "HmacSha256Mac", + "ShortHashSeed", + "BinaryFuseFilterType", + "SerializedBinaryFuseFilter", ]; #[must_use] @@ -45591,6 +46178,9 @@ impl TypeVariant { Self::ScpQuorumSet => "ScpQuorumSet", Self::ConfigSettingContractExecutionLanesV0 => "ConfigSettingContractExecutionLanesV0", Self::ConfigSettingContractComputeV0 => "ConfigSettingContractComputeV0", + Self::ConfigSettingContractParallelComputeV0 => { + "ConfigSettingContractParallelComputeV0" + } Self::ConfigSettingContractLedgerCostV0 => "ConfigSettingContractLedgerCostV0", Self::ConfigSettingContractHistoricalDataV0 => "ConfigSettingContractHistoricalDataV0", Self::ConfigSettingContractEventsV0 => "ConfigSettingContractEventsV0", @@ -45759,6 +46349,9 @@ impl TypeVariant { Self::BucketMetadataExt => "BucketMetadataExt", Self::BucketEntry => "BucketEntry", Self::TxSetComponentType => "TxSetComponentType", + Self::TxExecutionThread => "TxExecutionThread", + Self::ParallelTxExecutionStage => "ParallelTxExecutionStage", + Self::ParallelTxsComponent => "ParallelTxsComponent", Self::TxSetComponent => "TxSetComponent", Self::TxSetComponentTxsMaybeDiscountedFee => "TxSetComponentTxsMaybeDiscountedFee", Self::TransactionPhase => "TransactionPhase", @@ -46027,12 +46620,15 @@ impl TypeVariant { Self::Curve25519Public => "Curve25519Public", Self::HmacSha256Key => "HmacSha256Key", Self::HmacSha256Mac => "HmacSha256Mac", + Self::ShortHashSeed => "ShortHashSeed", + Self::BinaryFuseFilterType => "BinaryFuseFilterType", + Self::SerializedBinaryFuseFilter => "SerializedBinaryFuseFilter", } } #[must_use] #[allow(clippy::too_many_lines)] - pub const fn variants() -> [TypeVariant; 437] { + pub const fn variants() -> [TypeVariant; 444] { Self::VARIANTS } @@ -46058,6 +46654,9 @@ impl TypeVariant { Self::ConfigSettingContractComputeV0 => { gen.into_root_schema_for::() } + Self::ConfigSettingContractParallelComputeV0 => { + gen.into_root_schema_for::() + } Self::ConfigSettingContractLedgerCostV0 => { gen.into_root_schema_for::() } @@ -46268,6 +46867,11 @@ impl TypeVariant { Self::BucketMetadataExt => gen.into_root_schema_for::(), Self::BucketEntry => gen.into_root_schema_for::(), Self::TxSetComponentType => gen.into_root_schema_for::(), + Self::TxExecutionThread => gen.into_root_schema_for::(), + Self::ParallelTxExecutionStage => { + gen.into_root_schema_for::() + } + Self::ParallelTxsComponent => gen.into_root_schema_for::(), Self::TxSetComponent => gen.into_root_schema_for::(), Self::TxSetComponentTxsMaybeDiscountedFee => { gen.into_root_schema_for::() @@ -46678,6 +47282,11 @@ impl TypeVariant { Self::Curve25519Public => gen.into_root_schema_for::(), Self::HmacSha256Key => gen.into_root_schema_for::(), Self::HmacSha256Mac => gen.into_root_schema_for::(), + Self::ShortHashSeed => gen.into_root_schema_for::(), + Self::BinaryFuseFilterType => gen.into_root_schema_for::(), + Self::SerializedBinaryFuseFilter => { + gen.into_root_schema_for::() + } } } } @@ -46715,6 +47324,9 @@ impl core::str::FromStr for TypeVariant { Ok(Self::ConfigSettingContractExecutionLanesV0) } "ConfigSettingContractComputeV0" => Ok(Self::ConfigSettingContractComputeV0), + "ConfigSettingContractParallelComputeV0" => { + Ok(Self::ConfigSettingContractParallelComputeV0) + } "ConfigSettingContractLedgerCostV0" => Ok(Self::ConfigSettingContractLedgerCostV0), "ConfigSettingContractHistoricalDataV0" => { Ok(Self::ConfigSettingContractHistoricalDataV0) @@ -46885,6 +47497,9 @@ impl core::str::FromStr for TypeVariant { "BucketMetadataExt" => Ok(Self::BucketMetadataExt), "BucketEntry" => Ok(Self::BucketEntry), "TxSetComponentType" => Ok(Self::TxSetComponentType), + "TxExecutionThread" => Ok(Self::TxExecutionThread), + "ParallelTxExecutionStage" => Ok(Self::ParallelTxExecutionStage), + "ParallelTxsComponent" => Ok(Self::ParallelTxsComponent), "TxSetComponent" => Ok(Self::TxSetComponent), "TxSetComponentTxsMaybeDiscountedFee" => Ok(Self::TxSetComponentTxsMaybeDiscountedFee), "TransactionPhase" => Ok(Self::TransactionPhase), @@ -47163,6 +47778,9 @@ impl core::str::FromStr for TypeVariant { "Curve25519Public" => Ok(Self::Curve25519Public), "HmacSha256Key" => Ok(Self::HmacSha256Key), "HmacSha256Mac" => Ok(Self::HmacSha256Mac), + "ShortHashSeed" => Ok(Self::ShortHashSeed), + "BinaryFuseFilterType" => Ok(Self::BinaryFuseFilterType), + "SerializedBinaryFuseFilter" => Ok(Self::SerializedBinaryFuseFilter), _ => Err(Error::Invalid), } } @@ -47190,6 +47808,7 @@ pub enum Type { ScpQuorumSet(Box), ConfigSettingContractExecutionLanesV0(Box), ConfigSettingContractComputeV0(Box), + ConfigSettingContractParallelComputeV0(Box), ConfigSettingContractLedgerCostV0(Box), ConfigSettingContractHistoricalDataV0(Box), ConfigSettingContractEventsV0(Box), @@ -47356,6 +47975,9 @@ pub enum Type { BucketMetadataExt(Box), BucketEntry(Box), TxSetComponentType(Box), + TxExecutionThread(Box), + ParallelTxExecutionStage(Box), + ParallelTxsComponent(Box), TxSetComponent(Box), TxSetComponentTxsMaybeDiscountedFee(Box), TransactionPhase(Box), @@ -47614,10 +48236,13 @@ pub enum Type { Curve25519Public(Box), HmacSha256Key(Box), HmacSha256Mac(Box), + ShortHashSeed(Box), + BinaryFuseFilterType(Box), + SerializedBinaryFuseFilter(Box), } impl Type { - pub const VARIANTS: [TypeVariant; 437] = [ + pub const VARIANTS: [TypeVariant; 444] = [ TypeVariant::Value, TypeVariant::ScpBallot, TypeVariant::ScpStatementType, @@ -47631,6 +48256,7 @@ impl Type { TypeVariant::ScpQuorumSet, TypeVariant::ConfigSettingContractExecutionLanesV0, TypeVariant::ConfigSettingContractComputeV0, + TypeVariant::ConfigSettingContractParallelComputeV0, TypeVariant::ConfigSettingContractLedgerCostV0, TypeVariant::ConfigSettingContractHistoricalDataV0, TypeVariant::ConfigSettingContractEventsV0, @@ -47797,6 +48423,9 @@ impl Type { TypeVariant::BucketMetadataExt, TypeVariant::BucketEntry, TypeVariant::TxSetComponentType, + TypeVariant::TxExecutionThread, + TypeVariant::ParallelTxExecutionStage, + TypeVariant::ParallelTxsComponent, TypeVariant::TxSetComponent, TypeVariant::TxSetComponentTxsMaybeDiscountedFee, TypeVariant::TransactionPhase, @@ -48055,8 +48684,11 @@ impl Type { TypeVariant::Curve25519Public, TypeVariant::HmacSha256Key, TypeVariant::HmacSha256Mac, + TypeVariant::ShortHashSeed, + TypeVariant::BinaryFuseFilterType, + TypeVariant::SerializedBinaryFuseFilter, ]; - pub const VARIANTS_STR: [&'static str; 437] = [ + pub const VARIANTS_STR: [&'static str; 444] = [ "Value", "ScpBallot", "ScpStatementType", @@ -48070,6 +48702,7 @@ impl Type { "ScpQuorumSet", "ConfigSettingContractExecutionLanesV0", "ConfigSettingContractComputeV0", + "ConfigSettingContractParallelComputeV0", "ConfigSettingContractLedgerCostV0", "ConfigSettingContractHistoricalDataV0", "ConfigSettingContractEventsV0", @@ -48236,6 +48869,9 @@ impl Type { "BucketMetadataExt", "BucketEntry", "TxSetComponentType", + "TxExecutionThread", + "ParallelTxExecutionStage", + "ParallelTxsComponent", "TxSetComponent", "TxSetComponentTxsMaybeDiscountedFee", "TransactionPhase", @@ -48494,6 +49130,9 @@ impl Type { "Curve25519Public", "HmacSha256Key", "HmacSha256Mac", + "ShortHashSeed", + "BinaryFuseFilterType", + "SerializedBinaryFuseFilter", ]; #[cfg(feature = "std")] @@ -48553,6 +49192,11 @@ impl Type { ConfigSettingContractComputeV0::read_xdr(r)?, ))) }), + TypeVariant::ConfigSettingContractParallelComputeV0 => r.with_limited_depth(|r| { + Ok(Self::ConfigSettingContractParallelComputeV0(Box::new( + ConfigSettingContractParallelComputeV0::read_xdr(r)?, + ))) + }), TypeVariant::ConfigSettingContractLedgerCostV0 => r.with_limited_depth(|r| { Ok(Self::ConfigSettingContractLedgerCostV0(Box::new( ConfigSettingContractLedgerCostV0::read_xdr(r)?, @@ -49239,6 +49883,21 @@ impl Type { TxSetComponentType::read_xdr(r)?, ))) }), + TypeVariant::TxExecutionThread => r.with_limited_depth(|r| { + Ok(Self::TxExecutionThread(Box::new( + TxExecutionThread::read_xdr(r)?, + ))) + }), + TypeVariant::ParallelTxExecutionStage => r.with_limited_depth(|r| { + Ok(Self::ParallelTxExecutionStage(Box::new( + ParallelTxExecutionStage::read_xdr(r)?, + ))) + }), + TypeVariant::ParallelTxsComponent => r.with_limited_depth(|r| { + Ok(Self::ParallelTxsComponent(Box::new( + ParallelTxsComponent::read_xdr(r)?, + ))) + }), TypeVariant::TxSetComponent => r.with_limited_depth(|r| { Ok(Self::TxSetComponent(Box::new(TxSetComponent::read_xdr(r)?))) }), @@ -50395,6 +51054,19 @@ impl Type { TypeVariant::HmacSha256Mac => r.with_limited_depth(|r| { Ok(Self::HmacSha256Mac(Box::new(HmacSha256Mac::read_xdr(r)?))) }), + TypeVariant::ShortHashSeed => r.with_limited_depth(|r| { + Ok(Self::ShortHashSeed(Box::new(ShortHashSeed::read_xdr(r)?))) + }), + TypeVariant::BinaryFuseFilterType => r.with_limited_depth(|r| { + Ok(Self::BinaryFuseFilterType(Box::new( + BinaryFuseFilterType::read_xdr(r)?, + ))) + }), + TypeVariant::SerializedBinaryFuseFilter => r.with_limited_depth(|r| { + Ok(Self::SerializedBinaryFuseFilter(Box::new( + SerializedBinaryFuseFilter::read_xdr(r)?, + ))) + }), } } @@ -50495,6 +51167,13 @@ impl Type { ) .map(|r| r.map(|t| Self::ConfigSettingContractComputeV0(Box::new(t)))), ), + TypeVariant::ConfigSettingContractParallelComputeV0 => Box::new( + ReadXdrIter::<_, ConfigSettingContractParallelComputeV0>::new( + &mut r.inner, + r.limits.clone(), + ) + .map(|r| r.map(|t| Self::ConfigSettingContractParallelComputeV0(Box::new(t)))), + ), TypeVariant::ConfigSettingContractLedgerCostV0 => Box::new( ReadXdrIter::<_, ConfigSettingContractLedgerCostV0>::new( &mut r.inner, @@ -51183,6 +51862,18 @@ impl Type { ReadXdrIter::<_, TxSetComponentType>::new(&mut r.inner, r.limits.clone()) .map(|r| r.map(|t| Self::TxSetComponentType(Box::new(t)))), ), + TypeVariant::TxExecutionThread => Box::new( + ReadXdrIter::<_, TxExecutionThread>::new(&mut r.inner, r.limits.clone()) + .map(|r| r.map(|t| Self::TxExecutionThread(Box::new(t)))), + ), + TypeVariant::ParallelTxExecutionStage => Box::new( + ReadXdrIter::<_, ParallelTxExecutionStage>::new(&mut r.inner, r.limits.clone()) + .map(|r| r.map(|t| Self::ParallelTxExecutionStage(Box::new(t)))), + ), + TypeVariant::ParallelTxsComponent => Box::new( + ReadXdrIter::<_, ParallelTxsComponent>::new(&mut r.inner, r.limits.clone()) + .map(|r| r.map(|t| Self::ParallelTxsComponent(Box::new(t)))), + ), TypeVariant::TxSetComponent => Box::new( ReadXdrIter::<_, TxSetComponent>::new(&mut r.inner, r.limits.clone()) .map(|r| r.map(|t| Self::TxSetComponent(Box::new(t)))), @@ -52321,6 +53012,18 @@ impl Type { ReadXdrIter::<_, HmacSha256Mac>::new(&mut r.inner, r.limits.clone()) .map(|r| r.map(|t| Self::HmacSha256Mac(Box::new(t)))), ), + TypeVariant::ShortHashSeed => Box::new( + ReadXdrIter::<_, ShortHashSeed>::new(&mut r.inner, r.limits.clone()) + .map(|r| r.map(|t| Self::ShortHashSeed(Box::new(t)))), + ), + TypeVariant::BinaryFuseFilterType => Box::new( + ReadXdrIter::<_, BinaryFuseFilterType>::new(&mut r.inner, r.limits.clone()) + .map(|r| r.map(|t| Self::BinaryFuseFilterType(Box::new(t)))), + ), + TypeVariant::SerializedBinaryFuseFilter => Box::new( + ReadXdrIter::<_, SerializedBinaryFuseFilter>::new(&mut r.inner, r.limits.clone()) + .map(|r| r.map(|t| Self::SerializedBinaryFuseFilter(Box::new(t)))), + ), } } @@ -52392,6 +53095,13 @@ impl Type { ) .map(|r| r.map(|t| Self::ConfigSettingContractComputeV0(Box::new(t.0)))), ), + TypeVariant::ConfigSettingContractParallelComputeV0 => Box::new( + ReadXdrIter::<_, Frame>::new( + &mut r.inner, + r.limits.clone(), + ) + .map(|r| r.map(|t| Self::ConfigSettingContractParallelComputeV0(Box::new(t.0)))), + ), TypeVariant::ConfigSettingContractLedgerCostV0 => Box::new( ReadXdrIter::<_, Frame>::new( &mut r.inner, @@ -53164,6 +53874,21 @@ impl Type { ReadXdrIter::<_, Frame>::new(&mut r.inner, r.limits.clone()) .map(|r| r.map(|t| Self::TxSetComponentType(Box::new(t.0)))), ), + TypeVariant::TxExecutionThread => Box::new( + ReadXdrIter::<_, Frame>::new(&mut r.inner, r.limits.clone()) + .map(|r| r.map(|t| Self::TxExecutionThread(Box::new(t.0)))), + ), + TypeVariant::ParallelTxExecutionStage => Box::new( + ReadXdrIter::<_, Frame>::new( + &mut r.inner, + r.limits.clone(), + ) + .map(|r| r.map(|t| Self::ParallelTxExecutionStage(Box::new(t.0)))), + ), + TypeVariant::ParallelTxsComponent => Box::new( + ReadXdrIter::<_, Frame>::new(&mut r.inner, r.limits.clone()) + .map(|r| r.map(|t| Self::ParallelTxsComponent(Box::new(t.0)))), + ), TypeVariant::TxSetComponent => Box::new( ReadXdrIter::<_, Frame>::new(&mut r.inner, r.limits.clone()) .map(|r| r.map(|t| Self::TxSetComponent(Box::new(t.0)))), @@ -54502,6 +55227,21 @@ impl Type { ReadXdrIter::<_, Frame>::new(&mut r.inner, r.limits.clone()) .map(|r| r.map(|t| Self::HmacSha256Mac(Box::new(t.0)))), ), + TypeVariant::ShortHashSeed => Box::new( + ReadXdrIter::<_, Frame>::new(&mut r.inner, r.limits.clone()) + .map(|r| r.map(|t| Self::ShortHashSeed(Box::new(t.0)))), + ), + TypeVariant::BinaryFuseFilterType => Box::new( + ReadXdrIter::<_, Frame>::new(&mut r.inner, r.limits.clone()) + .map(|r| r.map(|t| Self::BinaryFuseFilterType(Box::new(t.0)))), + ), + TypeVariant::SerializedBinaryFuseFilter => Box::new( + ReadXdrIter::<_, Frame>::new( + &mut r.inner, + r.limits.clone(), + ) + .map(|r| r.map(|t| Self::SerializedBinaryFuseFilter(Box::new(t.0)))), + ), } } @@ -54565,6 +55305,13 @@ impl Type { ReadXdrIter::<_, ConfigSettingContractComputeV0>::new(dec, r.limits.clone()) .map(|r| r.map(|t| Self::ConfigSettingContractComputeV0(Box::new(t)))), ), + TypeVariant::ConfigSettingContractParallelComputeV0 => Box::new( + ReadXdrIter::<_, ConfigSettingContractParallelComputeV0>::new( + dec, + r.limits.clone(), + ) + .map(|r| r.map(|t| Self::ConfigSettingContractParallelComputeV0(Box::new(t)))), + ), TypeVariant::ConfigSettingContractLedgerCostV0 => Box::new( ReadXdrIter::<_, ConfigSettingContractLedgerCostV0>::new(dec, r.limits.clone()) .map(|r| r.map(|t| Self::ConfigSettingContractLedgerCostV0(Box::new(t)))), @@ -55232,6 +55979,18 @@ impl Type { ReadXdrIter::<_, TxSetComponentType>::new(dec, r.limits.clone()) .map(|r| r.map(|t| Self::TxSetComponentType(Box::new(t)))), ), + TypeVariant::TxExecutionThread => Box::new( + ReadXdrIter::<_, TxExecutionThread>::new(dec, r.limits.clone()) + .map(|r| r.map(|t| Self::TxExecutionThread(Box::new(t)))), + ), + TypeVariant::ParallelTxExecutionStage => Box::new( + ReadXdrIter::<_, ParallelTxExecutionStage>::new(dec, r.limits.clone()) + .map(|r| r.map(|t| Self::ParallelTxExecutionStage(Box::new(t)))), + ), + TypeVariant::ParallelTxsComponent => Box::new( + ReadXdrIter::<_, ParallelTxsComponent>::new(dec, r.limits.clone()) + .map(|r| r.map(|t| Self::ParallelTxsComponent(Box::new(t)))), + ), TypeVariant::TxSetComponent => Box::new( ReadXdrIter::<_, TxSetComponent>::new(dec, r.limits.clone()) .map(|r| r.map(|t| Self::TxSetComponent(Box::new(t)))), @@ -56283,6 +57042,18 @@ impl Type { ReadXdrIter::<_, HmacSha256Mac>::new(dec, r.limits.clone()) .map(|r| r.map(|t| Self::HmacSha256Mac(Box::new(t)))), ), + TypeVariant::ShortHashSeed => Box::new( + ReadXdrIter::<_, ShortHashSeed>::new(dec, r.limits.clone()) + .map(|r| r.map(|t| Self::ShortHashSeed(Box::new(t)))), + ), + TypeVariant::BinaryFuseFilterType => Box::new( + ReadXdrIter::<_, BinaryFuseFilterType>::new(dec, r.limits.clone()) + .map(|r| r.map(|t| Self::BinaryFuseFilterType(Box::new(t)))), + ), + TypeVariant::SerializedBinaryFuseFilter => Box::new( + ReadXdrIter::<_, SerializedBinaryFuseFilter>::new(dec, r.limits.clone()) + .map(|r| r.map(|t| Self::SerializedBinaryFuseFilter(Box::new(t)))), + ), } } @@ -56343,6 +57114,9 @@ impl Type { TypeVariant::ConfigSettingContractComputeV0 => Ok( Self::ConfigSettingContractComputeV0(Box::new(serde_json::from_reader(r)?)), ), + TypeVariant::ConfigSettingContractParallelComputeV0 => Ok( + Self::ConfigSettingContractParallelComputeV0(Box::new(serde_json::from_reader(r)?)), + ), TypeVariant::ConfigSettingContractLedgerCostV0 => Ok( Self::ConfigSettingContractLedgerCostV0(Box::new(serde_json::from_reader(r)?)), ), @@ -56775,6 +57549,15 @@ impl Type { TypeVariant::TxSetComponentType => Ok(Self::TxSetComponentType(Box::new( serde_json::from_reader(r)?, ))), + TypeVariant::TxExecutionThread => Ok(Self::TxExecutionThread(Box::new( + serde_json::from_reader(r)?, + ))), + TypeVariant::ParallelTxExecutionStage => Ok(Self::ParallelTxExecutionStage(Box::new( + serde_json::from_reader(r)?, + ))), + TypeVariant::ParallelTxsComponent => Ok(Self::ParallelTxsComponent(Box::new( + serde_json::from_reader(r)?, + ))), TypeVariant::TxSetComponent => { Ok(Self::TxSetComponent(Box::new(serde_json::from_reader(r)?))) } @@ -57499,6 +58282,15 @@ impl Type { TypeVariant::HmacSha256Mac => { Ok(Self::HmacSha256Mac(Box::new(serde_json::from_reader(r)?))) } + TypeVariant::ShortHashSeed => { + Ok(Self::ShortHashSeed(Box::new(serde_json::from_reader(r)?))) + } + TypeVariant::BinaryFuseFilterType => Ok(Self::BinaryFuseFilterType(Box::new( + serde_json::from_reader(r)?, + ))), + TypeVariant::SerializedBinaryFuseFilter => Ok(Self::SerializedBinaryFuseFilter( + Box::new(serde_json::from_reader(r)?), + )), } } @@ -57521,6 +58313,7 @@ impl Type { Self::ScpQuorumSet(ref v) => v.as_ref(), Self::ConfigSettingContractExecutionLanesV0(ref v) => v.as_ref(), Self::ConfigSettingContractComputeV0(ref v) => v.as_ref(), + Self::ConfigSettingContractParallelComputeV0(ref v) => v.as_ref(), Self::ConfigSettingContractLedgerCostV0(ref v) => v.as_ref(), Self::ConfigSettingContractHistoricalDataV0(ref v) => v.as_ref(), Self::ConfigSettingContractEventsV0(ref v) => v.as_ref(), @@ -57687,6 +58480,9 @@ impl Type { Self::BucketMetadataExt(ref v) => v.as_ref(), Self::BucketEntry(ref v) => v.as_ref(), Self::TxSetComponentType(ref v) => v.as_ref(), + Self::TxExecutionThread(ref v) => v.as_ref(), + Self::ParallelTxExecutionStage(ref v) => v.as_ref(), + Self::ParallelTxsComponent(ref v) => v.as_ref(), Self::TxSetComponent(ref v) => v.as_ref(), Self::TxSetComponentTxsMaybeDiscountedFee(ref v) => v.as_ref(), Self::TransactionPhase(ref v) => v.as_ref(), @@ -57945,6 +58741,9 @@ impl Type { Self::Curve25519Public(ref v) => v.as_ref(), Self::HmacSha256Key(ref v) => v.as_ref(), Self::HmacSha256Mac(ref v) => v.as_ref(), + Self::ShortHashSeed(ref v) => v.as_ref(), + Self::BinaryFuseFilterType(ref v) => v.as_ref(), + Self::SerializedBinaryFuseFilter(ref v) => v.as_ref(), } } @@ -57967,6 +58766,9 @@ impl Type { "ConfigSettingContractExecutionLanesV0" } Self::ConfigSettingContractComputeV0(_) => "ConfigSettingContractComputeV0", + Self::ConfigSettingContractParallelComputeV0(_) => { + "ConfigSettingContractParallelComputeV0" + } Self::ConfigSettingContractLedgerCostV0(_) => "ConfigSettingContractLedgerCostV0", Self::ConfigSettingContractHistoricalDataV0(_) => { "ConfigSettingContractHistoricalDataV0" @@ -58137,6 +58939,9 @@ impl Type { Self::BucketMetadataExt(_) => "BucketMetadataExt", Self::BucketEntry(_) => "BucketEntry", Self::TxSetComponentType(_) => "TxSetComponentType", + Self::TxExecutionThread(_) => "TxExecutionThread", + Self::ParallelTxExecutionStage(_) => "ParallelTxExecutionStage", + Self::ParallelTxsComponent(_) => "ParallelTxsComponent", Self::TxSetComponent(_) => "TxSetComponent", Self::TxSetComponentTxsMaybeDiscountedFee(_) => "TxSetComponentTxsMaybeDiscountedFee", Self::TransactionPhase(_) => "TransactionPhase", @@ -58413,12 +59218,15 @@ impl Type { Self::Curve25519Public(_) => "Curve25519Public", Self::HmacSha256Key(_) => "HmacSha256Key", Self::HmacSha256Mac(_) => "HmacSha256Mac", + Self::ShortHashSeed(_) => "ShortHashSeed", + Self::BinaryFuseFilterType(_) => "BinaryFuseFilterType", + Self::SerializedBinaryFuseFilter(_) => "SerializedBinaryFuseFilter", } } #[must_use] #[allow(clippy::too_many_lines)] - pub const fn variants() -> [TypeVariant; 437] { + pub const fn variants() -> [TypeVariant; 444] { Self::VARIANTS } @@ -58441,6 +59249,9 @@ impl Type { TypeVariant::ConfigSettingContractExecutionLanesV0 } Self::ConfigSettingContractComputeV0(_) => TypeVariant::ConfigSettingContractComputeV0, + Self::ConfigSettingContractParallelComputeV0(_) => { + TypeVariant::ConfigSettingContractParallelComputeV0 + } Self::ConfigSettingContractLedgerCostV0(_) => { TypeVariant::ConfigSettingContractLedgerCostV0 } @@ -58621,6 +59432,9 @@ impl Type { Self::BucketMetadataExt(_) => TypeVariant::BucketMetadataExt, Self::BucketEntry(_) => TypeVariant::BucketEntry, Self::TxSetComponentType(_) => TypeVariant::TxSetComponentType, + Self::TxExecutionThread(_) => TypeVariant::TxExecutionThread, + Self::ParallelTxExecutionStage(_) => TypeVariant::ParallelTxExecutionStage, + Self::ParallelTxsComponent(_) => TypeVariant::ParallelTxsComponent, Self::TxSetComponent(_) => TypeVariant::TxSetComponent, Self::TxSetComponentTxsMaybeDiscountedFee(_) => { TypeVariant::TxSetComponentTxsMaybeDiscountedFee @@ -58929,6 +59743,9 @@ impl Type { Self::Curve25519Public(_) => TypeVariant::Curve25519Public, Self::HmacSha256Key(_) => TypeVariant::HmacSha256Key, Self::HmacSha256Mac(_) => TypeVariant::HmacSha256Mac, + Self::ShortHashSeed(_) => TypeVariant::ShortHashSeed, + Self::BinaryFuseFilterType(_) => TypeVariant::BinaryFuseFilterType, + Self::SerializedBinaryFuseFilter(_) => TypeVariant::SerializedBinaryFuseFilter, } } } @@ -58964,6 +59781,7 @@ impl WriteXdr for Type { Self::ScpQuorumSet(v) => v.write_xdr(w), Self::ConfigSettingContractExecutionLanesV0(v) => v.write_xdr(w), Self::ConfigSettingContractComputeV0(v) => v.write_xdr(w), + Self::ConfigSettingContractParallelComputeV0(v) => v.write_xdr(w), Self::ConfigSettingContractLedgerCostV0(v) => v.write_xdr(w), Self::ConfigSettingContractHistoricalDataV0(v) => v.write_xdr(w), Self::ConfigSettingContractEventsV0(v) => v.write_xdr(w), @@ -59130,6 +59948,9 @@ impl WriteXdr for Type { Self::BucketMetadataExt(v) => v.write_xdr(w), Self::BucketEntry(v) => v.write_xdr(w), Self::TxSetComponentType(v) => v.write_xdr(w), + Self::TxExecutionThread(v) => v.write_xdr(w), + Self::ParallelTxExecutionStage(v) => v.write_xdr(w), + Self::ParallelTxsComponent(v) => v.write_xdr(w), Self::TxSetComponent(v) => v.write_xdr(w), Self::TxSetComponentTxsMaybeDiscountedFee(v) => v.write_xdr(w), Self::TransactionPhase(v) => v.write_xdr(w), @@ -59388,6 +60209,9 @@ impl WriteXdr for Type { Self::Curve25519Public(v) => v.write_xdr(w), Self::HmacSha256Key(v) => v.write_xdr(w), Self::HmacSha256Mac(v) => v.write_xdr(w), + Self::ShortHashSeed(v) => v.write_xdr(w), + Self::BinaryFuseFilterType(v) => v.write_xdr(w), + Self::SerializedBinaryFuseFilter(v) => v.write_xdr(w), } } } diff --git a/xdr/curr b/xdr/curr index 70180d5e..78ef9860 160000 --- a/xdr/curr +++ b/xdr/curr @@ -1 +1 @@ -Subproject commit 70180d5e8d9caee9e8645ed8a38c36a8cf403cd9 +Subproject commit 78ef9860777bd53e75a8ce8b978131cade26b321 diff --git a/xdr/curr-version b/xdr/curr-version index 793097ad..94978e21 100644 --- a/xdr/curr-version +++ b/xdr/curr-version @@ -1 +1 @@ -70180d5e8d9caee9e8645ed8a38c36a8cf403cd9 \ No newline at end of file +78ef9860777bd53e75a8ce8b978131cade26b321 \ No newline at end of file diff --git a/xdr/next b/xdr/next index 38629ee4..c3f1a272 160000 --- a/xdr/next +++ b/xdr/next @@ -1 +1 @@ -Subproject commit 38629ee46fbc7dfb034e00c38b2ddb954c6dd41d +Subproject commit c3f1a272dcc9351fe23891c2857414f7befa8831 diff --git a/xdr/next-version b/xdr/next-version index 1ff2278b..ac84b0b2 100644 --- a/xdr/next-version +++ b/xdr/next-version @@ -1 +1 @@ -38629ee46fbc7dfb034e00c38b2ddb954c6dd41d \ No newline at end of file +c3f1a272dcc9351fe23891c2857414f7befa8831 \ No newline at end of file