From 7b46a60d914c1e5befd6a2d2c50d2fdf7e5eb1f0 Mon Sep 17 00:00:00 2001 From: Siddharth Suresh Date: Fri, 26 Jun 2026 16:14:46 -0700 Subject: [PATCH 1/3] Regenerate XDR for Protocol 28 (CAP-0084 Muxed Contract Addresses) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bump xdr submodule to stellar-xdr#306 head (7b56181), add the cap_0084_muxed_contract feature, and regenerate. Adds the SC_ADDRESS_TYPE_MUXED_CONTRACT arm on ScAddress and the MuxedContract struct, gated behind cap_0084_muxed_contract. str.rs: ScAddress Display is hand-written (CUSTOM_STR_IMPL); muxed contract addresses have no strkey encoding yet, so that arm returns Err — flagged for human review. Bumps crate version to 28.0.0. --- Cargo.lock | 2 +- Cargo.toml | 3 +- src/generated.rs | 5 +- src/generated/muxed_contract.rs | 58 ++++++++++++++++++ src/generated/sc_address.rs | 18 ++++++ src/generated/sc_address_type.rs | 14 +++++ .../soroban_transaction_meta_ext_v1.rs | 2 +- src/generated/type_enum.rs | 59 +++++++++++++++++++ src/lib.rs | 2 + src/str.rs | 5 ++ xdr | 2 +- xdr-definitions-json/xdr.json | 8 +-- xdr-json/LedgerCloseMeta.json | 2 +- xdr-json/LedgerCloseMetaBatch.json | 2 +- xdr-json/LedgerCloseMetaV0.json | 2 +- xdr-json/LedgerCloseMetaV1.json | 2 +- xdr-json/LedgerCloseMetaV2.json | 2 +- xdr-json/ScAddressType.json | 2 +- xdr-json/SorobanTransactionMeta.json | 2 +- xdr-json/SorobanTransactionMetaExt.json | 2 +- xdr-json/SorobanTransactionMetaExtV1.json | 2 +- xdr-json/SorobanTransactionMetaV2.json | 2 +- xdr-json/TransactionMeta.json | 2 +- xdr-json/TransactionMetaV3.json | 2 +- xdr-json/TransactionMetaV4.json | 2 +- xdr-json/TransactionResultMeta.json | 2 +- xdr-json/TransactionResultMetaV1.json | 2 +- xdr-version | 2 +- 28 files changed, 185 insertions(+), 25 deletions(-) create mode 100644 src/generated/muxed_contract.rs diff --git a/Cargo.lock b/Cargo.lock index 21c389e6..d710b98d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -736,7 +736,7 @@ dependencies = [ [[package]] name = "stellar-xdr" -version = "27.0.0" +version = "28.0.0" dependencies = [ "arbitrary", "base64", diff --git a/Cargo.toml b/Cargo.toml index 472d3b0e..4f818863 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -5,7 +5,7 @@ homepage = "https://github.com/stellar/rs-stellar-xdr" repository = "https://github.com/stellar/rs-stellar-xdr" authors = ["Stellar Development Foundation "] license = "Apache-2.0" -version = "27.0.0" +version = "28.0.0" edition = "2021" rust-version = "1.84.0" @@ -47,6 +47,7 @@ alloc = ["dep:hex", "dep:stellar-strkey", "escape-bytes/alloc", "dep:ethnum"] # Features from the XDR test_feature = [] cap_0083 = [] +cap_0084_muxed_contract = [] # Features available without any new dependencies. type_enum = [] diff --git a/src/generated.rs b/src/generated.rs index 38b27f6f..718f7035 100644 --- a/src/generated.rs +++ b/src/generated.rs @@ -59,7 +59,7 @@ pub const XDR_FILES_SHA256: [(&str, &str); 13] = [ ), ( "xdr/Stellar-ledger.x", - "93cdd4dd597d9f0b271762c2f3c81be8562e2004f4f019f539ca7d7e92167099", + "4c09454575c291e41b8f514255562a261f8f1cdefa7e8a20062b1108571621b5", ), ( "xdr/Stellar-overlay.x", @@ -4357,6 +4357,9 @@ pub use sc_address_type::*; mod muxed_ed25519_account; #[allow(unused_imports)] pub use muxed_ed25519_account::*; +mod muxed_contract; +#[allow(unused_imports)] +pub use muxed_contract::*; mod sc_address; #[allow(unused_imports)] pub use sc_address::*; diff --git a/src/generated/muxed_contract.rs b/src/generated/muxed_contract.rs new file mode 100644 index 00000000..9201397b --- /dev/null +++ b/src/generated/muxed_contract.rs @@ -0,0 +1,58 @@ +#[allow(unused_imports, clippy::wildcard_imports)] +use super::*; + +/// MuxedContract is an XDR Struct defined as: +/// +/// ```text +/// struct MuxedContract +/// { +/// uint64 id; +/// ContractID contractId; +/// }; +/// ``` +/// +#[cfg(feature = "cap_0084_muxed_contract")] +#[cfg_attr(feature = "alloc", derive(Default))] +#[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)] +#[cfg_attr(feature = "serde", cfg_eval::cfg_eval)] +#[cfg_attr(feature = "arbitrary", derive(Arbitrary))] +#[cfg_attr( + all(feature = "serde", feature = "alloc"), + serde_with::serde_as, + derive(serde::Serialize, serde::Deserialize), + serde(rename_all = "snake_case") +)] +#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))] +pub struct MuxedContract { + #[cfg_attr( + all(feature = "serde", feature = "alloc"), + serde_as(as = "NumberOrString") + )] + pub id: u64, + pub contract_id: ContractId, +} + +#[cfg(feature = "cap_0084_muxed_contract")] +impl ReadXdr for MuxedContract { + #[cfg(feature = "std")] + fn read_xdr(r: &mut Limited) -> Result { + r.with_limited_depth(|r| { + Ok(Self { + id: u64::read_xdr(r)?, + contract_id: ContractId::read_xdr(r)?, + }) + }) + } +} + +#[cfg(feature = "cap_0084_muxed_contract")] +impl WriteXdr for MuxedContract { + #[cfg(feature = "std")] + fn write_xdr(&self, w: &mut Limited) -> Result<(), Error> { + w.with_limited_depth(|w| { + self.id.write_xdr(w)?; + self.contract_id.write_xdr(w)?; + Ok(()) + }) + } +} diff --git a/src/generated/sc_address.rs b/src/generated/sc_address.rs index b43d9112..f77a58a8 100644 --- a/src/generated/sc_address.rs +++ b/src/generated/sc_address.rs @@ -16,6 +16,10 @@ use super::*; /// ClaimableBalanceID claimableBalanceId; /// case SC_ADDRESS_TYPE_LIQUIDITY_POOL: /// PoolID liquidityPoolId; +/// #ifdef CAP_0084_MUXED_CONTRACT +/// case SC_ADDRESS_TYPE_MUXED_CONTRACT: +/// MuxedContract muxedContract; +/// #endif /// }; /// ``` /// @@ -34,6 +38,8 @@ pub enum ScAddress { MuxedAccount(MuxedEd25519Account), ClaimableBalance(ClaimableBalanceId), LiquidityPool(PoolId), + #[cfg(feature = "cap_0084_muxed_contract")] + MuxedContract(MuxedContract), } #[cfg(feature = "alloc")] @@ -50,6 +56,8 @@ impl ScAddress { ScAddressType::MuxedAccount, ScAddressType::ClaimableBalance, ScAddressType::LiquidityPool, + #[cfg(feature = "cap_0084_muxed_contract")] + ScAddressType::MuxedContract, ]; pub const VARIANTS: [ScAddressType; Self::_VARIANTS.len()] = { let mut arr = [Self::_VARIANTS[0]; Self::_VARIANTS.len()]; @@ -66,6 +74,8 @@ impl ScAddress { "MuxedAccount", "ClaimableBalance", "LiquidityPool", + #[cfg(feature = "cap_0084_muxed_contract")] + "MuxedContract", ]; pub const VARIANTS_STR: [&'static str; Self::_VARIANTS_STR.len()] = { let mut arr = [Self::_VARIANTS_STR[0]; Self::_VARIANTS_STR.len()]; @@ -85,6 +95,8 @@ impl ScAddress { Self::MuxedAccount(_) => "MuxedAccount", Self::ClaimableBalance(_) => "ClaimableBalance", Self::LiquidityPool(_) => "LiquidityPool", + #[cfg(feature = "cap_0084_muxed_contract")] + Self::MuxedContract(_) => "MuxedContract", } } @@ -97,6 +109,8 @@ impl ScAddress { Self::MuxedAccount(_) => ScAddressType::MuxedAccount, Self::ClaimableBalance(_) => ScAddressType::ClaimableBalance, Self::LiquidityPool(_) => ScAddressType::LiquidityPool, + #[cfg(feature = "cap_0084_muxed_contract")] + Self::MuxedContract(_) => ScAddressType::MuxedContract, } } @@ -144,6 +158,8 @@ impl ReadXdr for ScAddress { Self::ClaimableBalance(ClaimableBalanceId::read_xdr(r)?) } ScAddressType::LiquidityPool => Self::LiquidityPool(PoolId::read_xdr(r)?), + #[cfg(feature = "cap_0084_muxed_contract")] + ScAddressType::MuxedContract => Self::MuxedContract(MuxedContract::read_xdr(r)?), #[allow(unreachable_patterns)] _ => return Err(Error::Invalid), }; @@ -164,6 +180,8 @@ impl WriteXdr for ScAddress { Self::MuxedAccount(v) => v.write_xdr(w)?, Self::ClaimableBalance(v) => v.write_xdr(w)?, Self::LiquidityPool(v) => v.write_xdr(w)?, + #[cfg(feature = "cap_0084_muxed_contract")] + Self::MuxedContract(v) => v.write_xdr(w)?, }; Ok(()) }) diff --git a/src/generated/sc_address_type.rs b/src/generated/sc_address_type.rs index 033e8dbe..761630ee 100644 --- a/src/generated/sc_address_type.rs +++ b/src/generated/sc_address_type.rs @@ -11,6 +11,10 @@ use super::*; /// SC_ADDRESS_TYPE_MUXED_ACCOUNT = 2, /// SC_ADDRESS_TYPE_CLAIMABLE_BALANCE = 3, /// SC_ADDRESS_TYPE_LIQUIDITY_POOL = 4 +/// #ifdef CAP_0084_MUXED_CONTRACT +/// , +/// SC_ADDRESS_TYPE_MUXED_CONTRACT = 5 +/// #endif /// }; /// ``` /// @@ -32,6 +36,8 @@ pub enum ScAddressType { MuxedAccount = 2, ClaimableBalance = 3, LiquidityPool = 4, + #[cfg(feature = "cap_0084_muxed_contract")] + MuxedContract = 5, } impl ScAddressType { @@ -41,6 +47,8 @@ impl ScAddressType { ScAddressType::MuxedAccount, ScAddressType::ClaimableBalance, ScAddressType::LiquidityPool, + #[cfg(feature = "cap_0084_muxed_contract")] + ScAddressType::MuxedContract, ]; pub const VARIANTS: [ScAddressType; Self::_VARIANTS.len()] = { let mut arr = [Self::_VARIANTS[0]; Self::_VARIANTS.len()]; @@ -57,6 +65,8 @@ impl ScAddressType { "MuxedAccount", "ClaimableBalance", "LiquidityPool", + #[cfg(feature = "cap_0084_muxed_contract")] + "MuxedContract", ]; pub const VARIANTS_STR: [&'static str; Self::_VARIANTS_STR.len()] = { let mut arr = [Self::_VARIANTS_STR[0]; Self::_VARIANTS_STR.len()]; @@ -76,6 +86,8 @@ impl ScAddressType { Self::MuxedAccount => "MuxedAccount", Self::ClaimableBalance => "ClaimableBalance", Self::LiquidityPool => "LiquidityPool", + #[cfg(feature = "cap_0084_muxed_contract")] + Self::MuxedContract => "MuxedContract", } } @@ -116,6 +128,8 @@ impl TryFrom for ScAddressType { 2 => ScAddressType::MuxedAccount, 3 => ScAddressType::ClaimableBalance, 4 => ScAddressType::LiquidityPool, + #[cfg(feature = "cap_0084_muxed_contract")] + 5 => ScAddressType::MuxedContract, #[allow(unreachable_patterns)] _ => return Err(Error::Invalid), }; diff --git a/src/generated/soroban_transaction_meta_ext_v1.rs b/src/generated/soroban_transaction_meta_ext_v1.rs index 825b9839..0aed7597 100644 --- a/src/generated/soroban_transaction_meta_ext_v1.rs +++ b/src/generated/soroban_transaction_meta_ext_v1.rs @@ -34,7 +34,7 @@ use super::*; /// // transactions, this will be `0` for failed transactions. /// int64 totalRefundableResourceFeeCharged; /// // Amount (in stroops) that has been charged for rent. -/// // This is a part of `totalNonRefundableResourceFeeCharged`. +/// // This is a part of `totalRefundableResourceFeeCharged`. /// int64 rentFeeCharged; /// }; /// ``` diff --git a/src/generated/type_enum.rs b/src/generated/type_enum.rs index e63d73c7..7d6751e3 100644 --- a/src/generated/type_enum.rs +++ b/src/generated/type_enum.rs @@ -88,6 +88,8 @@ pub enum TypeVariant { ContractExecutable, ScAddressType, MuxedEd25519Account, + #[cfg(feature = "cap_0084_muxed_contract")] + MuxedContract, ScAddress, ScVec, ScMap, @@ -568,6 +570,8 @@ impl TypeVariant { TypeVariant::ContractExecutable, TypeVariant::ScAddressType, TypeVariant::MuxedEd25519Account, + #[cfg(feature = "cap_0084_muxed_contract")] + TypeVariant::MuxedContract, TypeVariant::ScAddress, TypeVariant::ScVec, TypeVariant::ScMap, @@ -1054,6 +1058,8 @@ impl TypeVariant { "ContractExecutable", "ScAddressType", "MuxedEd25519Account", + #[cfg(feature = "cap_0084_muxed_contract")] + "MuxedContract", "ScAddress", "ScVec", "ScMap", @@ -1546,6 +1552,8 @@ impl TypeVariant { Self::ContractExecutable => "ContractExecutable", Self::ScAddressType => "ScAddressType", Self::MuxedEd25519Account => "MuxedEd25519Account", + #[cfg(feature = "cap_0084_muxed_contract")] + Self::MuxedContract => "MuxedContract", Self::ScAddress => "ScAddress", Self::ScVec => "ScVec", Self::ScMap => "ScMap", @@ -2079,6 +2087,8 @@ impl TypeVariant { Self::ContractExecutable => gen.into_root_schema_for::(), Self::ScAddressType => gen.into_root_schema_for::(), Self::MuxedEd25519Account => gen.into_root_schema_for::(), + #[cfg(feature = "cap_0084_muxed_contract")] + Self::MuxedContract => gen.into_root_schema_for::(), Self::ScAddress => gen.into_root_schema_for::(), Self::ScVec => gen.into_root_schema_for::(), Self::ScMap => gen.into_root_schema_for::(), @@ -2783,6 +2793,8 @@ impl core::str::FromStr for TypeVariant { "ContractExecutable" => Ok(Self::ContractExecutable), "ScAddressType" => Ok(Self::ScAddressType), "MuxedEd25519Account" => Ok(Self::MuxedEd25519Account), + #[cfg(feature = "cap_0084_muxed_contract")] + "MuxedContract" => Ok(Self::MuxedContract), "ScAddress" => Ok(Self::ScAddress), "ScVec" => Ok(Self::ScVec), "ScMap" => Ok(Self::ScMap), @@ -3299,6 +3311,8 @@ pub enum Type { ContractExecutable(Box), ScAddressType(Box), MuxedEd25519Account(Box), + #[cfg(feature = "cap_0084_muxed_contract")] + MuxedContract(Box), ScAddress(Box), ScVec(Box), ScMap(Box), @@ -3781,6 +3795,8 @@ impl Type { TypeVariant::ContractExecutable, TypeVariant::ScAddressType, TypeVariant::MuxedEd25519Account, + #[cfg(feature = "cap_0084_muxed_contract")] + TypeVariant::MuxedContract, TypeVariant::ScAddress, TypeVariant::ScVec, TypeVariant::ScMap, @@ -4267,6 +4283,8 @@ impl Type { "ContractExecutable", "ScAddressType", "MuxedEd25519Account", + #[cfg(feature = "cap_0084_muxed_contract")] + "MuxedContract", "ScAddress", "ScVec", "ScMap", @@ -5015,6 +5033,10 @@ impl Type { MuxedEd25519Account::read_xdr(r)?, ))) }), + #[cfg(feature = "cap_0084_muxed_contract")] + TypeVariant::MuxedContract => r.with_limited_depth(|r| { + Ok(Self::MuxedContract(Box::new(MuxedContract::read_xdr(r)?))) + }), TypeVariant::ScAddress => { r.with_limited_depth(|r| Ok(Self::ScAddress(Box::new(ScAddress::read_xdr(r)?)))) } @@ -7140,6 +7162,11 @@ impl Type { ReadXdrIter::<_, MuxedEd25519Account>::new(&mut r.inner, r.limits.clone()) .map(|r| r.map(|t| Self::MuxedEd25519Account(Box::new(t)))), ), + #[cfg(feature = "cap_0084_muxed_contract")] + TypeVariant::MuxedContract => Box::new( + ReadXdrIter::<_, MuxedContract>::new(&mut r.inner, r.limits.clone()) + .map(|r| r.map(|t| Self::MuxedContract(Box::new(t)))), + ), TypeVariant::ScAddress => Box::new( ReadXdrIter::<_, ScAddress>::new(&mut r.inner, r.limits.clone()) .map(|r| r.map(|t| Self::ScAddress(Box::new(t)))), @@ -9227,6 +9254,11 @@ impl Type { ReadXdrIter::<_, Frame>::new(&mut r.inner, r.limits.clone()) .map(|r| r.map(|t| Self::MuxedEd25519Account(Box::new(t.0)))), ), + #[cfg(feature = "cap_0084_muxed_contract")] + TypeVariant::MuxedContract => Box::new( + ReadXdrIter::<_, Frame>::new(&mut r.inner, r.limits.clone()) + .map(|r| r.map(|t| Self::MuxedContract(Box::new(t.0)))), + ), TypeVariant::ScAddress => Box::new( ReadXdrIter::<_, Frame>::new(&mut r.inner, r.limits.clone()) .map(|r| r.map(|t| Self::ScAddress(Box::new(t.0)))), @@ -11542,6 +11574,11 @@ impl Type { ReadXdrIter::<_, MuxedEd25519Account>::new(dec, r.limits.clone()) .map(|r| r.map(|t| Self::MuxedEd25519Account(Box::new(t)))), ), + #[cfg(feature = "cap_0084_muxed_contract")] + TypeVariant::MuxedContract => Box::new( + ReadXdrIter::<_, MuxedContract>::new(dec, r.limits.clone()) + .map(|r| r.map(|t| Self::MuxedContract(Box::new(t)))), + ), TypeVariant::ScAddress => Box::new( ReadXdrIter::<_, ScAddress>::new(dec, r.limits.clone()) .map(|r| r.map(|t| Self::ScAddress(Box::new(t)))), @@ -13415,6 +13452,10 @@ impl Type { TypeVariant::MuxedEd25519Account => Ok(Self::MuxedEd25519Account(Box::new( serde_json::from_reader(r)?, ))), + #[cfg(feature = "cap_0084_muxed_contract")] + TypeVariant::MuxedContract => { + Ok(Self::MuxedContract(Box::new(serde_json::from_reader(r)?))) + } TypeVariant::ScAddress => Ok(Self::ScAddress(Box::new(serde_json::from_reader(r)?))), TypeVariant::ScVec => Ok(Self::ScVec(Box::new(serde_json::from_reader(r)?))), TypeVariant::ScMap => Ok(Self::ScMap(Box::new(serde_json::from_reader(r)?))), @@ -14756,6 +14797,10 @@ impl Type { TypeVariant::MuxedEd25519Account => Ok(Self::MuxedEd25519Account(Box::new( serde::de::Deserialize::deserialize(r)?, ))), + #[cfg(feature = "cap_0084_muxed_contract")] + TypeVariant::MuxedContract => Ok(Self::MuxedContract(Box::new( + serde::de::Deserialize::deserialize(r)?, + ))), TypeVariant::ScAddress => Ok(Self::ScAddress(Box::new( serde::de::Deserialize::deserialize(r)?, ))), @@ -16242,6 +16287,10 @@ impl Type { TypeVariant::MuxedEd25519Account => Ok(Self::MuxedEd25519Account(Box::new( MuxedEd25519Account::arbitrary(u)?, ))), + #[cfg(feature = "cap_0084_muxed_contract")] + TypeVariant::MuxedContract => { + Ok(Self::MuxedContract(Box::new(MuxedContract::arbitrary(u)?))) + } TypeVariant::ScAddress => Ok(Self::ScAddress(Box::new(ScAddress::arbitrary(u)?))), TypeVariant::ScVec => Ok(Self::ScVec(Box::new(ScVec::arbitrary(u)?))), TypeVariant::ScMap => Ok(Self::ScMap(Box::new(ScMap::arbitrary(u)?))), @@ -17471,6 +17520,8 @@ impl Type { TypeVariant::ContractExecutable => Self::ContractExecutable(Box::default()), TypeVariant::ScAddressType => Self::ScAddressType(Box::default()), TypeVariant::MuxedEd25519Account => Self::MuxedEd25519Account(Box::default()), + #[cfg(feature = "cap_0084_muxed_contract")] + TypeVariant::MuxedContract => Self::MuxedContract(Box::default()), TypeVariant::ScAddress => Self::ScAddress(Box::default()), TypeVariant::ScVec => Self::ScVec(Box::default()), TypeVariant::ScMap => Self::ScMap(Box::default()), @@ -18125,6 +18176,8 @@ impl Type { Self::ContractExecutable(ref v) => v.as_ref(), Self::ScAddressType(ref v) => v.as_ref(), Self::MuxedEd25519Account(ref v) => v.as_ref(), + #[cfg(feature = "cap_0084_muxed_contract")] + Self::MuxedContract(ref v) => v.as_ref(), Self::ScAddress(ref v) => v.as_ref(), Self::ScVec(ref v) => v.as_ref(), Self::ScMap(ref v) => v.as_ref(), @@ -18613,6 +18666,8 @@ impl Type { Self::ContractExecutable(_) => "ContractExecutable", Self::ScAddressType(_) => "ScAddressType", Self::MuxedEd25519Account(_) => "MuxedEd25519Account", + #[cfg(feature = "cap_0084_muxed_contract")] + Self::MuxedContract(_) => "MuxedContract", Self::ScAddress(_) => "ScAddress", Self::ScVec(_) => "ScVec", Self::ScMap(_) => "ScMap", @@ -19137,6 +19192,8 @@ impl Type { Self::ContractExecutable(_) => TypeVariant::ContractExecutable, Self::ScAddressType(_) => TypeVariant::ScAddressType, Self::MuxedEd25519Account(_) => TypeVariant::MuxedEd25519Account, + #[cfg(feature = "cap_0084_muxed_contract")] + Self::MuxedContract(_) => TypeVariant::MuxedContract, Self::ScAddress(_) => TypeVariant::ScAddress, Self::ScVec(_) => TypeVariant::ScVec, Self::ScMap(_) => TypeVariant::ScMap, @@ -19699,6 +19756,8 @@ impl WriteXdr for Type { Self::ContractExecutable(v) => v.write_xdr(w), Self::ScAddressType(v) => v.write_xdr(w), Self::MuxedEd25519Account(v) => v.write_xdr(w), + #[cfg(feature = "cap_0084_muxed_contract")] + Self::MuxedContract(v) => v.write_xdr(w), Self::ScAddress(v) => v.write_xdr(w), Self::ScVec(v) => v.write_xdr(w), Self::ScMap(v) => v.write_xdr(w), diff --git a/src/lib.rs b/src/lib.rs index 21635663..4df1e825 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -121,6 +121,8 @@ pub const VERSION: Version = Version { "test_feature", #[cfg(feature = "cap_0083")] "cap_0083", + #[cfg(feature = "cap_0084_muxed_contract")] + "cap_0084_muxed_contract", ], }; diff --git a/src/str.rs b/src/str.rs index 26cff8bd..0efddfda 100644 --- a/src/str.rs +++ b/src/str.rs @@ -361,6 +361,11 @@ impl core::fmt::Display for ScAddress { } ScAddress::ClaimableBalance(claimable_balance_id) => claimable_balance_id.fmt(f), ScAddress::LiquidityPool(pool_id) => pool_id.fmt(f), + // Muxed contract addresses (CAP-0084) have no strkey encoding yet + // (stellar-strkey has no variant for them), so there is no string + // representation to produce. Flagged for human review. + #[cfg(feature = "cap_0084_muxed_contract")] + ScAddress::MuxedContract(_) => Err(core::fmt::Error), } } } diff --git a/xdr b/xdr index 68fa1ac5..7b561814 160000 --- a/xdr +++ b/xdr @@ -1 +1 @@ -Subproject commit 68fa1ac55692f68ad2a2ca549d0a283273554439 +Subproject commit 7b5618146590e15d2e250538dccbc7c89ac55c58 diff --git a/xdr-definitions-json/xdr.json b/xdr-definitions-json/xdr.json index 5e1544da..f0c2f395 100644 --- a/xdr-definitions-json/xdr.json +++ b/xdr-definitions-json/xdr.json @@ -39,7 +39,7 @@ }, { "name": "xdr/Stellar-ledger.x", - "sha256": "93cdd4dd597d9f0b271762c2f3c81be8562e2004f4f019f539ca7d7e92167099" + "sha256": "4c09454575c291e41b8f514255562a261f8f1cdefa7e8a20062b1108571621b5" }, { "name": "xdr/Stellar-overlay.x", @@ -3470,7 +3470,7 @@ { "kind": "enum", "name": "SCAddressType", - "source": "enum SCAddressType\n{\n SC_ADDRESS_TYPE_ACCOUNT = 0,\n SC_ADDRESS_TYPE_CONTRACT = 1,\n SC_ADDRESS_TYPE_MUXED_ACCOUNT = 2,\n SC_ADDRESS_TYPE_CLAIMABLE_BALANCE = 3,\n SC_ADDRESS_TYPE_LIQUIDITY_POOL = 4\n};", + "source": "enum SCAddressType\n{\n SC_ADDRESS_TYPE_ACCOUNT = 0,\n SC_ADDRESS_TYPE_CONTRACT = 1,\n SC_ADDRESS_TYPE_MUXED_ACCOUNT = 2,\n SC_ADDRESS_TYPE_CLAIMABLE_BALANCE = 3,\n SC_ADDRESS_TYPE_LIQUIDITY_POOL = 4\n#ifdef CAP_0084_MUXED_CONTRACT\n ,\n SC_ADDRESS_TYPE_MUXED_CONTRACT = 5\n#endif\n};", "file_index": 5, "member_prefix": "SC_ADDRESS_TYPE_", "members": [ @@ -3523,7 +3523,7 @@ "kind": "union", "name": "SCAddress", "fixed_size": null, - "source": "union SCAddress switch (SCAddressType type)\n{\ncase SC_ADDRESS_TYPE_ACCOUNT:\n AccountID accountId;\ncase SC_ADDRESS_TYPE_CONTRACT:\n ContractID contractId;\ncase SC_ADDRESS_TYPE_MUXED_ACCOUNT:\n MuxedEd25519Account muxedAccount;\ncase SC_ADDRESS_TYPE_CLAIMABLE_BALANCE:\n ClaimableBalanceID claimableBalanceId;\ncase SC_ADDRESS_TYPE_LIQUIDITY_POOL:\n PoolID liquidityPoolId;\n};", + "source": "union SCAddress switch (SCAddressType type)\n{\ncase SC_ADDRESS_TYPE_ACCOUNT:\n AccountID accountId;\ncase SC_ADDRESS_TYPE_CONTRACT:\n ContractID contractId;\ncase SC_ADDRESS_TYPE_MUXED_ACCOUNT:\n MuxedEd25519Account muxedAccount;\ncase SC_ADDRESS_TYPE_CLAIMABLE_BALANCE:\n ClaimableBalanceID claimableBalanceId;\ncase SC_ADDRESS_TYPE_LIQUIDITY_POOL:\n PoolID liquidityPoolId;\n#ifdef CAP_0084_MUXED_CONTRACT\ncase SC_ADDRESS_TYPE_MUXED_CONTRACT:\n MuxedContract muxedContract;\n#endif\n};", "file_index": 5, "discriminant": { "name": "type", @@ -8468,7 +8468,7 @@ "kind": "struct", "name": "SorobanTransactionMetaExtV1", "fixed_size": 28, - "source": "struct SorobanTransactionMetaExtV1\n{\n ExtensionPoint ext;\n\n // The following are the components of the overall Soroban resource fee\n // charged for the transaction.\n // The following relation holds:\n // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged`\n // where `resourceFeeCharged` is the overall fee charged for the \n // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` \n // i.e.we never charge more than the declared resource fee.\n // The inclusion fee for charged the Soroban transaction can be found using \n // the following equation:\n // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n // Total amount (in stroops) that has been charged for non-refundable\n // Soroban resources.\n // Non-refundable resources are charged based on the usage declared in\n // the transaction envelope (such as `instructions`, `readBytes` etc.) and \n // is charged regardless of the success of the transaction.\n int64 totalNonRefundableResourceFeeCharged;\n // Total amount (in stroops) that has been charged for refundable\n // Soroban resource fees.\n // Currently this comprises the rent fee (`rentFeeCharged`) and the\n // fee for the events and return value.\n // Refundable resources are charged based on the actual resources usage.\n // Since currently refundable resources are only used for the successful\n // transactions, this will be `0` for failed transactions.\n int64 totalRefundableResourceFeeCharged;\n // Amount (in stroops) that has been charged for rent.\n // This is a part of `totalNonRefundableResourceFeeCharged`.\n int64 rentFeeCharged;\n};", + "source": "struct SorobanTransactionMetaExtV1\n{\n ExtensionPoint ext;\n\n // The following are the components of the overall Soroban resource fee\n // charged for the transaction.\n // The following relation holds:\n // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged`\n // where `resourceFeeCharged` is the overall fee charged for the \n // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` \n // i.e.we never charge more than the declared resource fee.\n // The inclusion fee for charged the Soroban transaction can be found using \n // the following equation:\n // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n // Total amount (in stroops) that has been charged for non-refundable\n // Soroban resources.\n // Non-refundable resources are charged based on the usage declared in\n // the transaction envelope (such as `instructions`, `readBytes` etc.) and \n // is charged regardless of the success of the transaction.\n int64 totalNonRefundableResourceFeeCharged;\n // Total amount (in stroops) that has been charged for refundable\n // Soroban resource fees.\n // Currently this comprises the rent fee (`rentFeeCharged`) and the\n // fee for the events and return value.\n // Refundable resources are charged based on the actual resources usage.\n // Since currently refundable resources are only used for the successful\n // transactions, this will be `0` for failed transactions.\n int64 totalRefundableResourceFeeCharged;\n // Amount (in stroops) that has been charged for rent.\n // This is a part of `totalRefundableResourceFeeCharged`.\n int64 rentFeeCharged;\n};", "file_index": 9, "fields": [ { diff --git a/xdr-json/LedgerCloseMeta.json b/xdr-json/LedgerCloseMeta.json index 980b7bee..83893f47 100644 --- a/xdr-json/LedgerCloseMeta.json +++ b/xdr-json/LedgerCloseMeta.json @@ -6572,7 +6572,7 @@ ] }, "SorobanTransactionMetaExtV1": { - "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalNonRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", + "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", "type": "object", "required": [ "ext", diff --git a/xdr-json/LedgerCloseMetaBatch.json b/xdr-json/LedgerCloseMetaBatch.json index 5c802962..70d85f57 100644 --- a/xdr-json/LedgerCloseMetaBatch.json +++ b/xdr-json/LedgerCloseMetaBatch.json @@ -6598,7 +6598,7 @@ ] }, "SorobanTransactionMetaExtV1": { - "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalNonRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", + "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", "type": "object", "required": [ "ext", diff --git a/xdr-json/LedgerCloseMetaV0.json b/xdr-json/LedgerCloseMetaV0.json index 7e946e3b..2f5f58a4 100644 --- a/xdr-json/LedgerCloseMetaV0.json +++ b/xdr-json/LedgerCloseMetaV0.json @@ -6319,7 +6319,7 @@ ] }, "SorobanTransactionMetaExtV1": { - "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalNonRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", + "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", "type": "object", "required": [ "ext", diff --git a/xdr-json/LedgerCloseMetaV1.json b/xdr-json/LedgerCloseMetaV1.json index 0269fbd5..2e086e9b 100644 --- a/xdr-json/LedgerCloseMetaV1.json +++ b/xdr-json/LedgerCloseMetaV1.json @@ -6436,7 +6436,7 @@ ] }, "SorobanTransactionMetaExtV1": { - "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalNonRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", + "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", "type": "object", "required": [ "ext", diff --git a/xdr-json/LedgerCloseMetaV2.json b/xdr-json/LedgerCloseMetaV2.json index 4614ba3f..e9905093 100644 --- a/xdr-json/LedgerCloseMetaV2.json +++ b/xdr-json/LedgerCloseMetaV2.json @@ -6428,7 +6428,7 @@ ] }, "SorobanTransactionMetaExtV1": { - "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalNonRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", + "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", "type": "object", "required": [ "ext", diff --git a/xdr-json/ScAddressType.json b/xdr-json/ScAddressType.json index 1dad7bd4..79ffd709 100644 --- a/xdr-json/ScAddressType.json +++ b/xdr-json/ScAddressType.json @@ -1,7 +1,7 @@ { "$schema": "https://json-schema.org/draft/2019-09/schema", "title": "ScAddressType", - "description": "ScAddressType is an XDR Enum defined as:\n\n```text enum SCAddressType { SC_ADDRESS_TYPE_ACCOUNT = 0, SC_ADDRESS_TYPE_CONTRACT = 1, SC_ADDRESS_TYPE_MUXED_ACCOUNT = 2, SC_ADDRESS_TYPE_CLAIMABLE_BALANCE = 3, SC_ADDRESS_TYPE_LIQUIDITY_POOL = 4 }; ```", + "description": "ScAddressType is an XDR Enum defined as:\n\n```text enum SCAddressType { SC_ADDRESS_TYPE_ACCOUNT = 0, SC_ADDRESS_TYPE_CONTRACT = 1, SC_ADDRESS_TYPE_MUXED_ACCOUNT = 2, SC_ADDRESS_TYPE_CLAIMABLE_BALANCE = 3, SC_ADDRESS_TYPE_LIQUIDITY_POOL = 4 #ifdef CAP_0084_MUXED_CONTRACT , SC_ADDRESS_TYPE_MUXED_CONTRACT = 5 #endif }; ```", "type": "string", "enum": [ "account", diff --git a/xdr-json/SorobanTransactionMeta.json b/xdr-json/SorobanTransactionMeta.json index 29ac16e0..9f4f67ed 100644 --- a/xdr-json/SorobanTransactionMeta.json +++ b/xdr-json/SorobanTransactionMeta.json @@ -661,7 +661,7 @@ ] }, "SorobanTransactionMetaExtV1": { - "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalNonRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", + "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", "type": "object", "required": [ "ext", diff --git a/xdr-json/SorobanTransactionMetaExt.json b/xdr-json/SorobanTransactionMetaExt.json index 5e057a0a..7a448922 100644 --- a/xdr-json/SorobanTransactionMetaExt.json +++ b/xdr-json/SorobanTransactionMetaExt.json @@ -36,7 +36,7 @@ ] }, "SorobanTransactionMetaExtV1": { - "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalNonRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", + "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", "type": "object", "required": [ "ext", diff --git a/xdr-json/SorobanTransactionMetaExtV1.json b/xdr-json/SorobanTransactionMetaExtV1.json index c06e542d..bbc9b422 100644 --- a/xdr-json/SorobanTransactionMetaExtV1.json +++ b/xdr-json/SorobanTransactionMetaExtV1.json @@ -1,7 +1,7 @@ { "$schema": "https://json-schema.org/draft/2019-09/schema", "title": "SorobanTransactionMetaExtV1", - "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalNonRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", + "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", "type": "object", "required": [ "ext", diff --git a/xdr-json/SorobanTransactionMetaV2.json b/xdr-json/SorobanTransactionMetaV2.json index 6b30bf29..638aa497 100644 --- a/xdr-json/SorobanTransactionMetaV2.json +++ b/xdr-json/SorobanTransactionMetaV2.json @@ -557,7 +557,7 @@ ] }, "SorobanTransactionMetaExtV1": { - "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalNonRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", + "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", "type": "object", "required": [ "ext", diff --git a/xdr-json/TransactionMeta.json b/xdr-json/TransactionMeta.json index 0e35b445..d710c72b 100644 --- a/xdr-json/TransactionMeta.json +++ b/xdr-json/TransactionMeta.json @@ -2820,7 +2820,7 @@ ] }, "SorobanTransactionMetaExtV1": { - "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalNonRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", + "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", "type": "object", "required": [ "ext", diff --git a/xdr-json/TransactionMetaV3.json b/xdr-json/TransactionMetaV3.json index b31f868c..3540837f 100644 --- a/xdr-json/TransactionMetaV3.json +++ b/xdr-json/TransactionMetaV3.json @@ -2768,7 +2768,7 @@ ] }, "SorobanTransactionMetaExtV1": { - "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalNonRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", + "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", "type": "object", "required": [ "ext", diff --git a/xdr-json/TransactionMetaV4.json b/xdr-json/TransactionMetaV4.json index afe057e1..6cf8b7dc 100644 --- a/xdr-json/TransactionMetaV4.json +++ b/xdr-json/TransactionMetaV4.json @@ -2764,7 +2764,7 @@ ] }, "SorobanTransactionMetaExtV1": { - "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalNonRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", + "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", "type": "object", "required": [ "ext", diff --git a/xdr-json/TransactionResultMeta.json b/xdr-json/TransactionResultMeta.json index 6db19f5b..c2fa2bf8 100644 --- a/xdr-json/TransactionResultMeta.json +++ b/xdr-json/TransactionResultMeta.json @@ -3946,7 +3946,7 @@ ] }, "SorobanTransactionMetaExtV1": { - "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalNonRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", + "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", "type": "object", "required": [ "ext", diff --git a/xdr-json/TransactionResultMetaV1.json b/xdr-json/TransactionResultMetaV1.json index cc363d71..3b476658 100644 --- a/xdr-json/TransactionResultMetaV1.json +++ b/xdr-json/TransactionResultMetaV1.json @@ -3954,7 +3954,7 @@ ] }, "SorobanTransactionMetaExtV1": { - "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalNonRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", + "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", "type": "object", "required": [ "ext", diff --git a/xdr-version b/xdr-version index 4c676364..ba7f3cf6 100644 --- a/xdr-version +++ b/xdr-version @@ -1 +1 @@ -68fa1ac55692f68ad2a2ca549d0a283273554439 \ No newline at end of file +7b5618146590e15d2e250538dccbc7c89ac55c58 \ No newline at end of file From 8f826caa99f3b4c55e4d958eb5b6a9a1dbbf9873 Mon Sep 17 00:00:00 2001 From: Siddharth Suresh Date: Wed, 1 Jul 2026 15:02:59 -0700 Subject: [PATCH 2/3] Regenerate from stellar-xdr X: restore ledger.x base hash 93cdd4dd (drop #304 comment) --- src/generated.rs | 2 +- src/generated/soroban_transaction_meta_ext_v1.rs | 2 +- xdr | 2 +- xdr-version | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/generated.rs b/src/generated.rs index 718f7035..a4a0644d 100644 --- a/src/generated.rs +++ b/src/generated.rs @@ -59,7 +59,7 @@ pub const XDR_FILES_SHA256: [(&str, &str); 13] = [ ), ( "xdr/Stellar-ledger.x", - "4c09454575c291e41b8f514255562a261f8f1cdefa7e8a20062b1108571621b5", + "93cdd4dd597d9f0b271762c2f3c81be8562e2004f4f019f539ca7d7e92167099", ), ( "xdr/Stellar-overlay.x", diff --git a/src/generated/soroban_transaction_meta_ext_v1.rs b/src/generated/soroban_transaction_meta_ext_v1.rs index 0aed7597..825b9839 100644 --- a/src/generated/soroban_transaction_meta_ext_v1.rs +++ b/src/generated/soroban_transaction_meta_ext_v1.rs @@ -34,7 +34,7 @@ use super::*; /// // transactions, this will be `0` for failed transactions. /// int64 totalRefundableResourceFeeCharged; /// // Amount (in stroops) that has been charged for rent. -/// // This is a part of `totalRefundableResourceFeeCharged`. +/// // This is a part of `totalNonRefundableResourceFeeCharged`. /// int64 rentFeeCharged; /// }; /// ``` diff --git a/xdr b/xdr index 7b561814..787382ef 160000 --- a/xdr +++ b/xdr @@ -1 +1 @@ -Subproject commit 7b5618146590e15d2e250538dccbc7c89ac55c58 +Subproject commit 787382ef2099cca168ca1cb282730d6b7b9e2f16 diff --git a/xdr-version b/xdr-version index ba7f3cf6..e728393c 100644 --- a/xdr-version +++ b/xdr-version @@ -1 +1 @@ -7b5618146590e15d2e250538dccbc7c89ac55c58 \ No newline at end of file +787382ef2099cca168ca1cb282730d6b7b9e2f16 \ No newline at end of file From 4761390051f63390df4cacc8af211e72b2cd71ba Mon Sep 17 00:00:00 2001 From: Siddharth Suresh Date: Wed, 1 Jul 2026 15:55:34 -0700 Subject: [PATCH 3/3] Regenerate JSON schemas from stellar-xdr#306 head (align ledger.x hash 93cdd4dd) --- xdr-definitions-json/xdr.json | 4 ++-- xdr-json/LedgerCloseMeta.json | 2 +- xdr-json/LedgerCloseMetaBatch.json | 2 +- xdr-json/LedgerCloseMetaV0.json | 2 +- xdr-json/LedgerCloseMetaV1.json | 2 +- xdr-json/LedgerCloseMetaV2.json | 2 +- xdr-json/SorobanTransactionMeta.json | 2 +- xdr-json/SorobanTransactionMetaExt.json | 2 +- xdr-json/SorobanTransactionMetaExtV1.json | 2 +- xdr-json/SorobanTransactionMetaV2.json | 2 +- xdr-json/TransactionMeta.json | 2 +- xdr-json/TransactionMetaV3.json | 2 +- xdr-json/TransactionMetaV4.json | 2 +- xdr-json/TransactionResultMeta.json | 2 +- xdr-json/TransactionResultMetaV1.json | 2 +- 15 files changed, 16 insertions(+), 16 deletions(-) diff --git a/xdr-definitions-json/xdr.json b/xdr-definitions-json/xdr.json index f0c2f395..301e3f3d 100644 --- a/xdr-definitions-json/xdr.json +++ b/xdr-definitions-json/xdr.json @@ -39,7 +39,7 @@ }, { "name": "xdr/Stellar-ledger.x", - "sha256": "4c09454575c291e41b8f514255562a261f8f1cdefa7e8a20062b1108571621b5" + "sha256": "93cdd4dd597d9f0b271762c2f3c81be8562e2004f4f019f539ca7d7e92167099" }, { "name": "xdr/Stellar-overlay.x", @@ -8468,7 +8468,7 @@ "kind": "struct", "name": "SorobanTransactionMetaExtV1", "fixed_size": 28, - "source": "struct SorobanTransactionMetaExtV1\n{\n ExtensionPoint ext;\n\n // The following are the components of the overall Soroban resource fee\n // charged for the transaction.\n // The following relation holds:\n // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged`\n // where `resourceFeeCharged` is the overall fee charged for the \n // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` \n // i.e.we never charge more than the declared resource fee.\n // The inclusion fee for charged the Soroban transaction can be found using \n // the following equation:\n // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n // Total amount (in stroops) that has been charged for non-refundable\n // Soroban resources.\n // Non-refundable resources are charged based on the usage declared in\n // the transaction envelope (such as `instructions`, `readBytes` etc.) and \n // is charged regardless of the success of the transaction.\n int64 totalNonRefundableResourceFeeCharged;\n // Total amount (in stroops) that has been charged for refundable\n // Soroban resource fees.\n // Currently this comprises the rent fee (`rentFeeCharged`) and the\n // fee for the events and return value.\n // Refundable resources are charged based on the actual resources usage.\n // Since currently refundable resources are only used for the successful\n // transactions, this will be `0` for failed transactions.\n int64 totalRefundableResourceFeeCharged;\n // Amount (in stroops) that has been charged for rent.\n // This is a part of `totalRefundableResourceFeeCharged`.\n int64 rentFeeCharged;\n};", + "source": "struct SorobanTransactionMetaExtV1\n{\n ExtensionPoint ext;\n\n // The following are the components of the overall Soroban resource fee\n // charged for the transaction.\n // The following relation holds:\n // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged`\n // where `resourceFeeCharged` is the overall fee charged for the \n // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` \n // i.e.we never charge more than the declared resource fee.\n // The inclusion fee for charged the Soroban transaction can be found using \n // the following equation:\n // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n // Total amount (in stroops) that has been charged for non-refundable\n // Soroban resources.\n // Non-refundable resources are charged based on the usage declared in\n // the transaction envelope (such as `instructions`, `readBytes` etc.) and \n // is charged regardless of the success of the transaction.\n int64 totalNonRefundableResourceFeeCharged;\n // Total amount (in stroops) that has been charged for refundable\n // Soroban resource fees.\n // Currently this comprises the rent fee (`rentFeeCharged`) and the\n // fee for the events and return value.\n // Refundable resources are charged based on the actual resources usage.\n // Since currently refundable resources are only used for the successful\n // transactions, this will be `0` for failed transactions.\n int64 totalRefundableResourceFeeCharged;\n // Amount (in stroops) that has been charged for rent.\n // This is a part of `totalNonRefundableResourceFeeCharged`.\n int64 rentFeeCharged;\n};", "file_index": 9, "fields": [ { diff --git a/xdr-json/LedgerCloseMeta.json b/xdr-json/LedgerCloseMeta.json index 83893f47..980b7bee 100644 --- a/xdr-json/LedgerCloseMeta.json +++ b/xdr-json/LedgerCloseMeta.json @@ -6572,7 +6572,7 @@ ] }, "SorobanTransactionMetaExtV1": { - "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", + "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalNonRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", "type": "object", "required": [ "ext", diff --git a/xdr-json/LedgerCloseMetaBatch.json b/xdr-json/LedgerCloseMetaBatch.json index 70d85f57..5c802962 100644 --- a/xdr-json/LedgerCloseMetaBatch.json +++ b/xdr-json/LedgerCloseMetaBatch.json @@ -6598,7 +6598,7 @@ ] }, "SorobanTransactionMetaExtV1": { - "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", + "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalNonRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", "type": "object", "required": [ "ext", diff --git a/xdr-json/LedgerCloseMetaV0.json b/xdr-json/LedgerCloseMetaV0.json index 2f5f58a4..7e946e3b 100644 --- a/xdr-json/LedgerCloseMetaV0.json +++ b/xdr-json/LedgerCloseMetaV0.json @@ -6319,7 +6319,7 @@ ] }, "SorobanTransactionMetaExtV1": { - "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", + "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalNonRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", "type": "object", "required": [ "ext", diff --git a/xdr-json/LedgerCloseMetaV1.json b/xdr-json/LedgerCloseMetaV1.json index 2e086e9b..0269fbd5 100644 --- a/xdr-json/LedgerCloseMetaV1.json +++ b/xdr-json/LedgerCloseMetaV1.json @@ -6436,7 +6436,7 @@ ] }, "SorobanTransactionMetaExtV1": { - "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", + "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalNonRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", "type": "object", "required": [ "ext", diff --git a/xdr-json/LedgerCloseMetaV2.json b/xdr-json/LedgerCloseMetaV2.json index e9905093..4614ba3f 100644 --- a/xdr-json/LedgerCloseMetaV2.json +++ b/xdr-json/LedgerCloseMetaV2.json @@ -6428,7 +6428,7 @@ ] }, "SorobanTransactionMetaExtV1": { - "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", + "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalNonRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", "type": "object", "required": [ "ext", diff --git a/xdr-json/SorobanTransactionMeta.json b/xdr-json/SorobanTransactionMeta.json index 9f4f67ed..29ac16e0 100644 --- a/xdr-json/SorobanTransactionMeta.json +++ b/xdr-json/SorobanTransactionMeta.json @@ -661,7 +661,7 @@ ] }, "SorobanTransactionMetaExtV1": { - "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", + "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalNonRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", "type": "object", "required": [ "ext", diff --git a/xdr-json/SorobanTransactionMetaExt.json b/xdr-json/SorobanTransactionMetaExt.json index 7a448922..5e057a0a 100644 --- a/xdr-json/SorobanTransactionMetaExt.json +++ b/xdr-json/SorobanTransactionMetaExt.json @@ -36,7 +36,7 @@ ] }, "SorobanTransactionMetaExtV1": { - "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", + "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalNonRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", "type": "object", "required": [ "ext", diff --git a/xdr-json/SorobanTransactionMetaExtV1.json b/xdr-json/SorobanTransactionMetaExtV1.json index bbc9b422..c06e542d 100644 --- a/xdr-json/SorobanTransactionMetaExtV1.json +++ b/xdr-json/SorobanTransactionMetaExtV1.json @@ -1,7 +1,7 @@ { "$schema": "https://json-schema.org/draft/2019-09/schema", "title": "SorobanTransactionMetaExtV1", - "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", + "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalNonRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", "type": "object", "required": [ "ext", diff --git a/xdr-json/SorobanTransactionMetaV2.json b/xdr-json/SorobanTransactionMetaV2.json index 638aa497..6b30bf29 100644 --- a/xdr-json/SorobanTransactionMetaV2.json +++ b/xdr-json/SorobanTransactionMetaV2.json @@ -557,7 +557,7 @@ ] }, "SorobanTransactionMetaExtV1": { - "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", + "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalNonRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", "type": "object", "required": [ "ext", diff --git a/xdr-json/TransactionMeta.json b/xdr-json/TransactionMeta.json index d710c72b..0e35b445 100644 --- a/xdr-json/TransactionMeta.json +++ b/xdr-json/TransactionMeta.json @@ -2820,7 +2820,7 @@ ] }, "SorobanTransactionMetaExtV1": { - "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", + "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalNonRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", "type": "object", "required": [ "ext", diff --git a/xdr-json/TransactionMetaV3.json b/xdr-json/TransactionMetaV3.json index 3540837f..b31f868c 100644 --- a/xdr-json/TransactionMetaV3.json +++ b/xdr-json/TransactionMetaV3.json @@ -2768,7 +2768,7 @@ ] }, "SorobanTransactionMetaExtV1": { - "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", + "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalNonRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", "type": "object", "required": [ "ext", diff --git a/xdr-json/TransactionMetaV4.json b/xdr-json/TransactionMetaV4.json index 6cf8b7dc..afe057e1 100644 --- a/xdr-json/TransactionMetaV4.json +++ b/xdr-json/TransactionMetaV4.json @@ -2764,7 +2764,7 @@ ] }, "SorobanTransactionMetaExtV1": { - "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", + "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalNonRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", "type": "object", "required": [ "ext", diff --git a/xdr-json/TransactionResultMeta.json b/xdr-json/TransactionResultMeta.json index c2fa2bf8..6db19f5b 100644 --- a/xdr-json/TransactionResultMeta.json +++ b/xdr-json/TransactionResultMeta.json @@ -3946,7 +3946,7 @@ ] }, "SorobanTransactionMetaExtV1": { - "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", + "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalNonRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", "type": "object", "required": [ "ext", diff --git a/xdr-json/TransactionResultMetaV1.json b/xdr-json/TransactionResultMetaV1.json index 3b476658..cc363d71 100644 --- a/xdr-json/TransactionResultMetaV1.json +++ b/xdr-json/TransactionResultMetaV1.json @@ -3954,7 +3954,7 @@ ] }, "SorobanTransactionMetaExtV1": { - "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", + "description": "SorobanTransactionMetaExtV1 is an XDR Struct defined as:\n\n```text struct SorobanTransactionMetaExtV1 { ExtensionPoint ext;\n\n// The following are the components of the overall Soroban resource fee // charged for the transaction. // The following relation holds: // `resourceFeeCharged = totalNonRefundableResourceFeeCharged + totalRefundableResourceFeeCharged` // where `resourceFeeCharged` is the overall fee charged for the // transaction. Also, `resourceFeeCharged` <= `sorobanData.resourceFee` // i.e.we never charge more than the declared resource fee. // The inclusion fee for charged the Soroban transaction can be found using // the following equation: // `result.feeCharged = resourceFeeCharged + inclusionFeeCharged`.\n\n// Total amount (in stroops) that has been charged for non-refundable // Soroban resources. // Non-refundable resources are charged based on the usage declared in // the transaction envelope (such as `instructions`, `readBytes` etc.) and // is charged regardless of the success of the transaction. int64 totalNonRefundableResourceFeeCharged; // Total amount (in stroops) that has been charged for refundable // Soroban resource fees. // Currently this comprises the rent fee (`rentFeeCharged`) and the // fee for the events and return value. // Refundable resources are charged based on the actual resources usage. // Since currently refundable resources are only used for the successful // transactions, this will be `0` for failed transactions. int64 totalRefundableResourceFeeCharged; // Amount (in stroops) that has been charged for rent. // This is a part of `totalNonRefundableResourceFeeCharged`. int64 rentFeeCharged; }; ```", "type": "object", "required": [ "ext",