@@ -14,7 +14,8 @@ All notable changes to this project will be documented in this file. This projec
 
 ### New Features
 * Add `ledgerbackend.LedgerStream`, a streaming-first, interchangeable ingestion source interface whose single `RawLedgers` method yields the raw XDR bytes of each ledger in a range. Constructors are provided for every backend: `NewBufferedStorageStream` (datastore), `NewCaptiveCoreStream` (captive stellar-core), and `NewRPCStream` (RPC). Each stream owns its backend's full lifecycle — set up on the first pull, torn down when iteration ends — and yields each ledger as a borrowed slice valid only until the next step. Pass `WithStreamMetrics(registry, namespace)` to `RawLedgers` to record `ledger_fetch_duration_seconds` (and, for captive-core, the `captive_stellar_core_*` suite), matching the metrics `WithMetrics` emits on the `GetLedger` path. [5944](https://github.com/stellar/go-stellar-sdk/pull/5944).
-* Add zero-copy XDR view extractors (**experimental** — signatures may still change) — the view-based twins of the parsed transaction path, reading directly off the generated `*View` accessors without `UnmarshalBinary`: `ExtractTxHashes` (per-ledger transaction hashes in apply order), `ExtractLedgerEvents` (per-transaction contract events + hash from one `TxProcessing` walk, as raw wire bytes), and the zero-copy `LedgerTransactionView` read path `LedgerTransactionViewByHash` / `LedgerTransactionViewRange` (the view parallel of `LedgerTransaction` / `LedgerTransactionReader`). `network.TransactionViewHasher` computes transaction hashes straight from envelope view bytes. Validated wire-identical against the parsed path across LCM V0/V1/V2 and `TransactionMeta` V0–V4, plus real-ledger equivalence tests and benchmarks against the eager-decode path on `ledger_58752000`. [5949](https://github.com/stellar/go-stellar-sdk/pull/5949).
+* Add `ExtractLedgerTxParts` + per-product functions (**experimental** — signatures may still change), the zero-copy per-ledger extraction API: one function owns the single `TxProcessing` walk and returns per-transaction handles (`LedgerTxParts`: hash, inner hash, fee-bump flag, lazy `Result`/`Meta` views), and each product is a plain function of those handles — `EventsFromTxParts` (contract events as raw wire bytes, `TxEvents`) and `FeesFromTxParts` (classic per-op and Soroban inclusion fee buckets, `LedgerFees` — what stellar-rpc's `getFeeStats` windows consume). Consumers compose exactly the products they need from exactly one walk. The fee classification reads only `TxProcessing` (soroban ⟺ `SorobanMeta` present; op count = per-operation result count), so it needs no `TxSet` read and no network passphrase; it matches stellar-rpc v1's `FeeWindows.IngestFees` on organic current-protocol traffic (deliberate deltas: transactions whose operations never ran — `txINTERNAL_ERROR`, or invalidated by an earlier transaction in the same ledger — are skipped since their results carry no per-operation list, and a charged resource fee above `FeeCharged` is an error instead of a uint64 wrap). This supersedes the earlier `ExtractTxHashes` / `ExtractLedgerEvents` bundles from [5949](https://github.com/stellar/go-stellar-sdk/pull/5949), which are removed (unreleased). Covered by table-driven fixtures across LCM V0/V1/V2 × `TransactionMeta` V0–V4 × result shapes and by real-pubnet-ledger equivalence tests; on `ledger_58752000` (249 txs) the walk measures ~0.29ms/17 allocs and all three products together ~0.58ms/154 allocs, vs ~5.7ms/~95k allocs for the parsed path. [5966](https://github.com/stellar/go-stellar-sdk/pull/5966), design: [stellar-rpc#912](https://github.com/stellar/stellar-rpc/issues/912).
+* Add the zero-copy `LedgerTransactionView` read path (**experimental** — signatures may still change), reading directly off the generated `*View` accessors without `UnmarshalBinary`: `LedgerTransactionViewByHash` / `LedgerTransactionViewRange` (the view parallel of `LedgerTransaction` / `LedgerTransactionReader`; these pair TxSet envelopes by hash and take the network passphrase). `network.TransactionViewHasher` computes transaction hashes straight from envelope view bytes. Validated wire-identical against the parsed path across LCM V0/V1/V2 and `TransactionMeta` V0–V4, plus real-ledger equivalence tests and benchmarks against the eager-decode path on `ledger_58752000`. [5949](https://github.com/stellar/go-stellar-sdk/pull/5949).
 
 
 ## v23.0.0
 
@@ -9,8 +9,8 @@ import (
 	"github.com/stellar/go-stellar-sdk/xdr"
 )
 
-// Benchmarks for the four public view extractors on a real pubnet ledger,
-// each with the eager-decode reference path as the A/B baseline. These
+// Benchmarks for the public view extractors on a real pubnet ledger, with
+// the eager-decode reference path as the A/B baseline where one exists. These
 // supersede the hand-rolled prototypes that lived in xdr
 // (extract_tx_bench_test.go, event_extraction_bench_test.go,
 // selective_decode_bench_test.go) — same fixture, but measuring the
@@ -40,7 +40,10 @@ func benchRefTransactions(b *testing.B, raw []byte) []ingest.LedgerTransaction {
 	}
 }
 
-func BenchmarkExtractTxHashes(b *testing.B) {
+// BenchmarkExtractLedgerTxParts measures the ONE TxProcessing walk every
+// per-ledger product reads from, against the full decode that yields the
+// same per-tx handles (hash + result + meta) on the parsed path.
+func BenchmarkExtractLedgerTxParts(b *testing.B) {
 	raw := loadRealLedger(b)
 
 	b.Run("full_decode", func(b *testing.B) {
@@ -57,16 +60,18 @@ func BenchmarkExtractTxHashes(b *testing.B) {
 	b.Run("view", func(b *testing.B) {
 		b.ReportAllocs()
 		for i := 0; i < b.N; i++ {
-			hashes, err := ingest.ExtractTxHashes(xdr.LedgerCloseMetaView(raw))
+			txParts, err := ingest.ExtractLedgerTxParts(xdr.LedgerCloseMetaView(raw))
 			if err != nil {
 				b.Fatal(err)
 			}
-			_ = hashes
+			_ = txParts
 		}
 	})
 }
 
-func BenchmarkExtractLedgerEvents(b *testing.B) {
+// BenchmarkEventsFromTxParts measures walk + events — the cold-backfill
+// composition (fees never computed).
+func BenchmarkEventsFromTxParts(b *testing.B) {
 	raw := loadRealLedger(b)
 
 	b.Run("full_decode", func(b *testing.B) {
@@ -85,15 +90,61 @@ func BenchmarkExtractLedgerEvents(b *testing.B) {
 	b.Run("view", func(b *testing.B) {
 		b.ReportAllocs()
 		for i := 0; i < b.N; i++ {
-			events, err := ingest.ExtractLedgerEvents(xdr.LedgerCloseMetaView(raw))
+			txParts, err := ingest.ExtractLedgerTxParts(xdr.LedgerCloseMetaView(raw))
 			if err != nil {
 				b.Fatal(err)
 			}
-			_ = events
+			txEvents, err := ingest.EventsFromTxParts(txParts)
+			if err != nil {
+				b.Fatal(err)
+			}
+			_ = txEvents
 		}
 	})
 }
 
+// BenchmarkFeesFromTxParts measures walk + fees — the fee-window replay
+// composition (events never computed).
+func BenchmarkFeesFromTxParts(b *testing.B) {
+	raw := loadRealLedger(b)
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		txParts, err := ingest.ExtractLedgerTxParts(xdr.LedgerCloseMetaView(raw))
+		if err != nil {
+			b.Fatal(err)
+		}
+		fees, err := ingest.FeesFromTxParts(txParts)
+		if err != nil {
+			b.Fatal(err)
+		}
+		_ = fees
+	}
+}
+
+// BenchmarkLedgerTxAllProducts measures walk + events + fees — the hot
+// ingestion composition, and the whole point of the parts/products split:
+// adding the fee product to an events consumer costs a read over the already
+// located handles, not a second walk.
+func BenchmarkLedgerTxAllProducts(b *testing.B) {
+	raw := loadRealLedger(b)
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		txParts, err := ingest.ExtractLedgerTxParts(xdr.LedgerCloseMetaView(raw))
+		if err != nil {
+			b.Fatal(err)
+		}
+		txEvents, err := ingest.EventsFromTxParts(txParts)
+		if err != nil {
+			b.Fatal(err)
+		}
+		fees, err := ingest.FeesFromTxParts(txParts)
+		if err != nil {
+			b.Fatal(err)
+		}
+		_, _ = txEvents, fees
+	}
+}
+
 func BenchmarkLedgerTransactionViewRange(b *testing.B) {
 	raw := loadRealLedger(b)
 
 
@@ -0,0 +1,84 @@
+package ingest
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/stellar/go-stellar-sdk/xdr"
+)
+
+// buildMultiPhaseLCM builds an LCM (V1 or V2 — both carry a
+// GeneralizedTransactionSet) whose TxSet holds BOTH phase shapes in one
+// ledger: txs[:split] sit in a V=0 components phase and txs[split:] in a V=1
+// parallel-txs phase (one stage, one cluster per tx). Envelopes are listed in
+// reverse within each phase, so nothing about the TxSet ordering matches the
+// TxProcessing apply order — pairing is by hash.
+func buildMultiPhaseLCM(t testing.TB, version int32, ledgerSeq uint32, closeTime int64, txs []txWithHash, split int) xdr.LedgerCloseMeta {
+	t.Helper()
+	require.Less(t, split, len(txs))
+
+	v0Envs := make([]xdr.TransactionEnvelope, split)
+	for i, tx := range txs[:split] {
+		v0Envs[split-1-i] = tx.env
+	}
+	comp := []xdr.TxSetComponent{{
+		Type:                  xdr.TxSetComponentTypeTxsetCompTxsMaybeDiscountedFee,
+		TxsMaybeDiscountedFee: &xdr.TxSetComponentTxsMaybeDiscountedFee{Txs: v0Envs},
+	}}
+
+	parallelTxs := txs[split:]
+	clusters := make(xdr.ParallelTxExecutionStage, 0, len(parallelTxs))
+	for i := range parallelTxs {
+		clusters = append(clusters, xdr.DependentTxCluster{parallelTxs[len(parallelTxs)-1-i].env})
+	}
+
+	phases := []xdr.TransactionPhase{
+		{V: 0, V0Components: &comp},
+		{V: 1, ParallelTxsComponent: &xdr.ParallelTxsComponent{
+			ExecutionStages: []xdr.ParallelTxExecutionStage{clusters},
+		}},
+	}
+
+	header := fixtureHeader(ledgerSeq, closeTime)
+	txSet := xdr.GeneralizedTransactionSet{V: 1, V1TxSet: &xdr.TransactionSetV1{Phases: phases}}
+
+	switch version {
+	case 1:
+		return xdr.LedgerCloseMeta{V: 1, V1: &xdr.LedgerCloseMetaV1{
+			LedgerHeader: header, TxSet: txSet, TxProcessing: resultMetas(txs),
+		}}
+	case 2:
+		return xdr.LedgerCloseMeta{V: 2, V2: &xdr.LedgerCloseMetaV2{
+			LedgerHeader: header, TxSet: txSet, TxProcessing: resultMetaV1s(txs),
+		}}
+	default:
+		t.Fatalf("unsupported version %d", version)
+		return xdr.LedgerCloseMeta{}
+	}
+}
+
+func TestFeesFromTxParts_MultiPhaseTxSet(t *testing.T) {
+	invoke := feeInvokeHostFunctionOp()
+	bump := feeBumpSequenceOp()
+	txs := []txWithHash{
+		// V0-components phase:
+		feeTxV1(t, []xdr.Operation{bump, bump}, false, feeMetaV1(), 101),      // classic 50
+		feeTxV1(t, []xdr.Operation{invoke}, true, feeMetaV3Ext1(40, 10), 100), // soroban 50
+		feeTxV1(t, []xdr.Operation{invoke}, true, feeMetaV3Ext0(), 100),       // skipped
+		// V1 parallel phase:
+		feeBumpFeeTx(t, []xdr.Operation{invoke}, true, feeMetaV4Ext1(30, 20), 300), // soroban 250
+		feeTxV1(t, []xdr.Operation{bump}, false, feeMetaV2(), 100),                 // classic 100
+		feeTxV0(t, []xdr.Operation{bump, bump, bump}, feeMetaV0(), 100),            // classic 33
+	}
+	for _, version := range []int32{1, 2} {
+		t.Run(fmt.Sprintf("lcmV%d", version), func(t *testing.T) {
+			lcm := buildMultiPhaseLCM(t, version, 8952, 1_700_086_000, txs, 3)
+			got := feesFromLCM(t, lcm)
+			assert.Equal(t, []uint64{50, 100, 33}, got.ClassicFeesPerOp)
+			assert.Equal(t, []uint64{50, 250}, got.SorobanInclusionFees)
+		})
+	}
+}