Bump stellar-xdr to 27.0.0 (#29)

### What

- Bump `stellar-xdr` from 26.0.0 to 27.0.0, renaming
`stellar_xdr::curr::` paths to `stellar_xdr::` (v27 exports all types at
the crate root).
- Add a regression test that parses a tx set whose Soroban auth entry
uses the CAP-0071 `SOROBAN_CREDENTIALS_ADDRESS_V2` credentials arm.

### Why

`scan --verify` currently reports 28 checkpoints (ledgers
63,401,919–63,479,423) as failed `transactions` files on all three
pubnet archives. The files are valid: they contain CAP-0071 (protocol
27) `AddressV2` Soroban credentials — which stellar-xdr 26 cannot
decode, so healthy archives are flagged as corrupt.

With this bump, all 28 previously-failing checkpoints verify clean on
`core_live_001/002/003`, and a full sweep of `core_live_001` from ledger
63,400,000 to the archive tip (18,904 files) passes with zero failures.

Author: jayz22

Cargo.lock

@@ -69,7 +69,7 @@ normalize-path = { version = "0.2.1" }
 sha2 = "0.10"
 # NB: the stellar-xdr needs to keep up-to-date with the latest major (protocol)
 # version or it may fail to parse the latest ledger format
-stellar-xdr = { version = "26.0.0", default-features = true, features = [] }
+stellar-xdr = { version = "27.0.0", default-features = true, features = [] }
 async-compression = { version = "0.4", features = ["tokio", "gzip"] }
 flate2 = "1.1.9"
 hex = "0.4"

Cargo.toml

@@ -20,7 +20,7 @@ use crate::xdr_verify::HashExt;
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 use std::path::Path;
-use stellar_xdr::curr::Hash;
+use stellar_xdr::Hash;
 use thiserror::Error;
 
 /// Current schema version.

src/report.rs

@@ -1865,9 +1865,7 @@ fn tamper_ledger_break_chain(archive_path: &Path) -> u32 {
     use flate2::read::GzDecoder;
     use sha2::{Digest, Sha256};
     use std::io::Read;
-    use stellar_xdr::curr::{
-        Frame, Hash, LedgerHeaderHistoryEntry, Limited, Limits, ReadXdr, WriteXdr,
-    };
+    use stellar_xdr::{Frame, Hash, LedgerHeaderHistoryEntry, Limited, Limits, ReadXdr, WriteXdr};
 
     let files = get_files_by_pattern(archive_path, "/ledger-");
     assert!(!files.is_empty(), "no ledger files found");

src/tests/repair_op_test.rs

@@ -2,7 +2,7 @@
 
 use crate::report::{ArchiveReport, Summary, REPORT_VERSION};
 use crate::utils::{FailureTracker, FileFlags};
-use stellar_xdr::curr::Hash;
+use stellar_xdr::Hash;
 
 fn sample_tracker() -> FailureTracker {
     let mut t = FailureTracker::default();

src/tests/report_test.rs

@@ -23,7 +23,7 @@ use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 use std::sync::{Arc, Mutex};
 use std::time::Instant;
-use stellar_xdr::curr::Hash;
+use stellar_xdr::Hash;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::TcpListener;
 use tower_http::services::ServeDir;
@@ -540,10 +540,10 @@ pub fn parse_transaction_entries(
 
 pub(crate) fn read_and_parse_ledger_file(
     path: &Path,
-) -> Vec<stellar_xdr::curr::LedgerHeaderHistoryEntry> {
+) -> Vec<stellar_xdr::LedgerHeaderHistoryEntry> {
     use flate2::read::GzDecoder;
     use std::io::Read as _;
-    use stellar_xdr::curr::{Frame, LedgerHeaderHistoryEntry, Limited, Limits, ReadXdr};
+    use stellar_xdr::{Frame, LedgerHeaderHistoryEntry, Limited, Limits, ReadXdr};
 
     let data = std::fs::read(path).expect("Failed to read ledger file");
     let mut decoder = GzDecoder::new(&data[..]);
@@ -560,9 +560,9 @@ pub(crate) fn read_and_parse_ledger_file(
         .collect()
 }
 
-pub(crate) fn recompute_entry_hash(entry: &mut stellar_xdr::curr::LedgerHeaderHistoryEntry) {
+pub(crate) fn recompute_entry_hash(entry: &mut stellar_xdr::LedgerHeaderHistoryEntry) {
     use sha2::{Digest, Sha256};
-    use stellar_xdr::curr::{Limits, WriteXdr};
+    use stellar_xdr::{Limits, WriteXdr};
 
     let header_xdr = entry
         .header
@@ -573,12 +573,12 @@ pub(crate) fn recompute_entry_hash(entry: &mut stellar_xdr::curr::LedgerHeaderHi
 
 pub(crate) fn write_ledger_header_entries_to_file(
     path: &Path,
-    entries: &[stellar_xdr::curr::LedgerHeaderHistoryEntry],
+    entries: &[stellar_xdr::LedgerHeaderHistoryEntry],
 ) {
     use flate2::write::GzEncoder;
     use flate2::Compression;
     use std::io::Write as _;
-    use stellar_xdr::curr::{Limits, WriteXdr};
+    use stellar_xdr::{Limits, WriteXdr};
 
     let mut data = Vec::new();
     for entry in entries {

src/tests/utils.rs

@@ -15,7 +15,7 @@ use flate2::Compression;
 use rstest::rstest;
 use std::io::Write;
 use std::path::{Path, PathBuf};
-use stellar_xdr::curr::Hash;
+use stellar_xdr::Hash;
 use tempfile::TempDir;
 
 fn pubnet_old_txset_archive_path() -> PathBuf {

src/tests/xdr_verification_e2e_test.rs

@@ -9,16 +9,18 @@ use crate::xdr_verify::{
 use rstest::rstest;
 use sha2::{Digest, Sha256};
 use std::collections::BTreeMap;
-use stellar_xdr::curr::{
-    AccountId, CreateAccountOp, GeneralizedTransactionSet, Hash, LedgerHeader, LedgerHeaderExt,
+use stellar_xdr::{
+    AccountId, ContractId, CreateAccountOp, GeneralizedTransactionSet, Hash, HostFunction,
+    InvokeContractArgs, InvokeHostFunctionOp, LedgerHeader, LedgerHeaderExt,
     LedgerHeaderHistoryEntry, LedgerHeaderHistoryEntryExt, LedgerScpMessages, Limits, Memo,
-    MuxedAccount, Operation, OperationBody, Preconditions, PublicKey, ScpHistoryEntry,
-    ScpHistoryEntryV0, SequenceNumber, TimePoint, Transaction, TransactionEnvelope,
-    TransactionHistoryEntry, TransactionHistoryEntryExt, TransactionHistoryResultEntry,
-    TransactionHistoryResultEntryExt, TransactionPhase, TransactionResult, TransactionResultExt,
-    TransactionResultPair, TransactionResultResult, TransactionResultSet, TransactionSet,
-    TransactionSetV1, TransactionV0, TransactionV0Envelope, TransactionV0Ext,
-    TransactionV1Envelope, Uint256, VecM, WriteXdr,
+    MuxedAccount, Operation, OperationBody, Preconditions, PublicKey, ScAddress, ScSymbol, ScVal,
+    ScpHistoryEntry, ScpHistoryEntryV0, SequenceNumber, SorobanAddressCredentials,
+    SorobanAuthorizationEntry, SorobanAuthorizedFunction, SorobanAuthorizedInvocation,
+    SorobanCredentials, TimePoint, Transaction, TransactionEnvelope, TransactionHistoryEntry,
+    TransactionHistoryEntryExt, TransactionHistoryResultEntry, TransactionHistoryResultEntryExt,
+    TransactionPhase, TransactionResult, TransactionResultExt, TransactionResultPair,
+    TransactionResultResult, TransactionResultSet, TransactionSet, TransactionSetV1, TransactionV0,
+    TransactionV0Envelope, TransactionV0Ext, TransactionV1Envelope, Uint256, VecM, WriteXdr,
 };
 
 fn frame_xdr<T: WriteXdr>(entry: &T) -> Vec<u8> {
@@ -76,7 +78,49 @@ fn tx_v1_envelope(id: u8) -> TransactionEnvelope {
             cond: Preconditions::None,
             memo: Memo::None,
             operations: vec![create_account_operation(id)].try_into().unwrap(),
-            ext: stellar_xdr::curr::TransactionExt::V0,
+            ext: stellar_xdr::TransactionExt::V0,
+        },
+        signatures: VecM::default(),
+    })
+}
+
+/// Soroban transaction whose auth entry uses the CAP-0071 (protocol 27)
+/// `SOROBAN_CREDENTIALS_ADDRESS_V2` arm, which pre-27 XDR cannot decode.
+fn tx_soroban_envelope_with_address_v2_auth(id: u8) -> TransactionEnvelope {
+    let invoke_args = InvokeContractArgs {
+        contract_address: ScAddress::Contract(ContractId(Hash([id; 32]))),
+        function_name: ScSymbol("transfer".try_into().unwrap()),
+        args: VecM::default(),
+    };
+    let auth = SorobanAuthorizationEntry {
+        credentials: SorobanCredentials::AddressV2(SorobanAddressCredentials {
+            address: ScAddress::Account(account_id(id)),
+            nonce: 1,
+            signature_expiration_ledger: 100,
+            signature: ScVal::Void,
+        }),
+        root_invocation: SorobanAuthorizedInvocation {
+            function: SorobanAuthorizedFunction::ContractFn(invoke_args.clone()),
+            sub_invocations: VecM::default(),
+        },
+    };
+    TransactionEnvelope::Tx(TransactionV1Envelope {
+        tx: Transaction {
+            source_account: muxed_account(id),
+            fee: 100,
+            seq_num: SequenceNumber(i64::from(id) + 1),
+            cond: Preconditions::None,
+            memo: Memo::None,
+            operations: vec![Operation {
+                source_account: None,
+                body: OperationBody::InvokeHostFunction(InvokeHostFunctionOp {
+                    host_function: HostFunction::InvokeContract(invoke_args),
+                    auth: vec![auth].try_into().unwrap(),
+                }),
+            }]
+            .try_into()
+            .unwrap(),
+            ext: stellar_xdr::TransactionExt::V0,
         },
         signatures: VecM::default(),
     })
@@ -106,8 +150,8 @@ fn v1_history_entry(
     prev_hash: [u8; 32],
     txs: Vec<TransactionEnvelope>,
 ) -> TransactionHistoryEntry {
-    let component = stellar_xdr::curr::TxSetComponent::TxsetCompTxsMaybeDiscountedFee(
-        stellar_xdr::curr::TxSetComponentTxsMaybeDiscountedFee {
+    let component = stellar_xdr::TxSetComponent::TxsetCompTxsMaybeDiscountedFee(
+        stellar_xdr::TxSetComponentTxsMaybeDiscountedFee {
             base_fee: None,
             txs: txs.try_into().unwrap(),
         },
@@ -166,11 +210,11 @@ fn create_minimal_ledger_header(
     LedgerHeader {
         ledger_version: 21,
         previous_ledger_hash: Hash(prev_hash),
-        scp_value: stellar_xdr::curr::StellarValue {
+        scp_value: stellar_xdr::StellarValue {
             tx_set_hash: Hash(tx_set_hash),
             close_time: TimePoint(0),
             upgrades: VecM::default(),
-            ext: stellar_xdr::curr::StellarValueExt::Basic,
+            ext: stellar_xdr::StellarValueExt::Basic,
         },
         tx_set_result_hash: Hash(result_hash),
         bucket_list_hash: Hash([0; 32]),
@@ -408,6 +452,22 @@ fn test_parse_transaction_entries_v1_non_empty() {
     assert!(!is_empty_tx_set_hash(&parsed[&100], &Hash(prev_hash)));
 }
 
+#[test]
+fn test_parse_transaction_entries_v1_with_cap71_address_v2_credentials() {
+    let prev_hash = [0x24; 32];
+    let entry = v1_history_entry(
+        100,
+        prev_hash,
+        vec![tx_soroban_envelope_with_address_v2_auth(1)],
+    );
+    let parsed = parse_transaction_entries(&frame_xdr(&entry)).unwrap();
+
+    let TransactionHistoryEntryExt::V1(generalized) = &entry.ext else {
+        panic!("expected V1 entry");
+    };
+    assert_eq!(parsed[&100], compute_v1_tx_set_hash(generalized).unwrap());
+}
+
 #[test]
 fn test_compute_v0_tx_set_hash_matches_manual_hash() {
     let prev_hash = [0x10; 32];
@@ -450,14 +510,12 @@ fn test_compute_v1_tx_set_hash_matches_manual_hash() {
     let generalized = GeneralizedTransactionSet::V1(TransactionSetV1 {
         previous_ledger_hash: Hash([0x11; 32]),
         phases: vec![TransactionPhase::V0(
-            vec![
-                stellar_xdr::curr::TxSetComponent::TxsetCompTxsMaybeDiscountedFee(
-                    stellar_xdr::curr::TxSetComponentTxsMaybeDiscountedFee {
-                        base_fee: None,
-                        txs: vec![tx_v1_envelope(1)].try_into().unwrap(),
-                    },
-                ),
-            ]
+            vec![stellar_xdr::TxSetComponent::TxsetCompTxsMaybeDiscountedFee(
+                stellar_xdr::TxSetComponentTxsMaybeDiscountedFee {
+                    base_fee: None,
+                    txs: vec![tx_v1_envelope(1)].try_into().unwrap(),
+                },
+            )]
             .try_into()
             .unwrap(),
         )]

src/tests/xdr_verify_test.rs

@@ -1,7 +1,7 @@
 use bytes::Buf;
 use std::collections::{BTreeMap, BTreeSet};
 use std::sync::atomic::{AtomicU64, Ordering};
-use stellar_xdr::curr::Hash;
+use stellar_xdr::Hash;
 use thiserror::Error;
 use tracing::{debug, error, info, warn};
 

src/utils.rs

@@ -26,7 +26,7 @@ use sha2::{Digest, Sha256};
 use std::collections::{BTreeMap, HashMap};
 use std::io::Cursor;
 use std::sync::Mutex;
-use stellar_xdr::curr::{
+use stellar_xdr::{
     Frame, GeneralizedTransactionSet, Hash, LedgerHeaderHistoryEntry, Limited, Limits, ReadXdr,
     ScpHistoryEntry, TransactionHistoryEntry, TransactionHistoryEntryExt,
     TransactionHistoryResultEntry, TransactionSetV1, VecM, WriteXdr,
@@ -44,13 +44,13 @@ pub(crate) const EMPTY_XDR_ARRAY_HASH: Hash = Hash([
 /// All-zero hash. Used as a sentinel for "no result entry expected."
 const ZERO_HASH: Hash = Hash([0; 32]);
 
-/// SHA-256 of `data` returned as a `stellar_xdr::curr::Hash` (the same newtype
+/// SHA-256 of `data` returned as a `stellar_xdr::Hash` (the same newtype
 /// used by ledger headers, tx-set hashes, etc.).
 fn sha256(data: &[u8]) -> Hash {
     Hash(Sha256::digest(data).into())
 }
 
-/// Extension methods for `stellar_xdr::curr::Hash`.
+/// Extension methods for `stellar_xdr::Hash`.
 pub(crate) trait HashExt {
     /// Hex-encode the 32 bytes (lowercase, no prefix).
     fn to_hex(&self) -> String;
@@ -730,10 +730,10 @@ pub(crate) fn is_empty_tx_set_hash(expected: &Hash, prev_hash: &Hash) -> bool {
 ///
 /// This matches stellar-core's `computeNonGeneralizedTxSetContentsHash()`.
 pub(crate) fn compute_v0_tx_set_hash(
-    tx_set: &stellar_xdr::curr::TransactionSet,
+    tx_set: &stellar_xdr::TransactionSet,
 ) -> Result<Hash, StorageError> {
     let mut serialized_txs = Vec::with_capacity(tx_set.txs.len());
-    for tx in tx_set.txs.iter() {
+    for tx in &tx_set.txs {
         let tx_xdr = tx.to_xdr(Limits::none()).map_err(|e| {
             StorageError::fatal(format!("failed to serialize TransactionEnvelope: {}", e))
         })?;
@@ -760,7 +760,7 @@ pub(crate) fn compute_v0_tx_set_hash(
 /// The V1 hash is simply SHA256 of the entire XDR-serialized struct.
 /// This matches stellar-core's `xdrSha256(xdrTxSet)`.
 pub(crate) fn compute_v1_tx_set_hash(
-    generalized_tx_set: &stellar_xdr::curr::GeneralizedTransactionSet,
+    generalized_tx_set: &stellar_xdr::GeneralizedTransactionSet,
 ) -> Result<Hash, StorageError> {
     let xdr = generalized_tx_set.to_xdr(Limits::none()).map_err(|e| {
         StorageError::fatal(format!(