Solana versioned transactions come in three live formats: legacy, v0 and v1. A decoder tells them apart from the first bytes. A first byte of 129 marks v1. Otherwise read past the signatures: if the message's first byte has its top bit set, the low bits give the version, and 0 means v0; if not, the transaction is legacy.
The first-byte test#
- Look at byte 0 of the transaction. If it is 129 (
0x81), it is a v1 transaction: the version byte comes first and the signatures come last. - Otherwise byte 0 starts a compact-u16 signature count. Read it and skip that many 64-byte signatures.
- You are now at the start of the message. A value of 128 or more there (high bit
0x80on) announces a versioned message, and subtracting 128 leaves the version number, which in practice is always 0. - A value below 128 announces a legacy message. In that case the byte you just read is not a marker at all: it is the required-signature count, the opening field of the header.
Two blocks from 18 November 2026, slots 470,901,815 and 470,901,816, held all three kinds side by side: 178 legacy, 331 v0 and 272 v1 transactions. A decoder that handles only one of them drops a large share of every block.
The prefix bit#
The version marker in legacy and v0 sits at the start of the message, not the start of the transaction. The Solana message code calls it MESSAGE_VERSION_PREFIX and gives it the value 0x80. The trick works because a legacy message begins with its count of required signatures, which never comes close to 128 in a legacy or v0 transaction limited to 1,232 bytes. So a set top bit can only mean "versioned".
Version 1 could not reuse that position, because its layout moves the signatures to the end. Its version byte, 129, sits at byte 0 of the whole transaction instead. 129 is 0x80 plus 1, the same prefix bit with the version number in the low bits.
Legacy messages#
A legacy message is the original layout: header, account keys, recent blockhash and instructions, as set out in what is inside a Solana transaction. Every account the transaction uses appears in its key list. That makes legacy the easiest format to decode, and also the most limited: with 32 bytes per key, the size cap leaves room for only a few dozen accounts.
v0 messages and their lookups#
v0 keeps the legacy layout and adds two things: the prefix byte before the header, and a list of address table lookups after the instructions. Each lookup names a table account and gives two lists of one-byte indexes into it, one for accounts the transaction may write and one for read-only accounts.
The addresses behind those indexes are not in the transaction at all. To know which accounts a v0 transaction touches, you need the lookup table's contents. Address lookup tables covers what that takes, and the lookup table problem explains why it is the hardest step for a shred decoder.
Version 1, the newest format#
Transaction v1 comes from SIMD-0385. On mainnet its feature, enable_tx_v1, was activated at slot 447,120,000, the start of epoch 1035. It uses a fixed layout instead of compact-u16 counts, puts signatures last, replaces Compute Budget instructions with a configuration mask, raises the size limit to 4,096 bytes and does not use lookup tables. The transaction v1 page describes each field.
Why the version matters when you decode from shreds#
Entries carry each transaction in its wire form with no length in front of it. You find where a transaction ends only by parsing it, and the parse depends on the version. Parse a v1 transaction as if it were legacy and two things go wrong at once: the ID you record is not its signature, and every transaction after it in the entry is misread.
The version also tells you how much more work a transaction needs. Legacy and v1 name every account inside the transaction; v0 may send you off to resolve a lookup table first. The Rust decoder handles all three.
Questions about versions#
How do I tell legacy from v0?#
Step over the signatures and compare the next byte with 128. At 128 or above you have v0; below it, legacy.
Does RPC show the version?#
Yes. getBlock and getTransaction report a version field, and you must pass maxSupportedTransactionVersion to receive versioned transactions at all. When you decode from raw bytes you work it out yourself, as above.
Is a v1 transaction a v0 transaction with extras?#
No. It is a separate layout with different field order, fixed-size counts and signatures at the end.
What the version byte does not tell you#
The version tells you how to parse the bytes, nothing more. It does not say whether the transaction is valid, whether it landed or succeeded, or which accounts a v0 lookup resolves to. Those answers need account state and execution results, which raw shreds do not carry.
Try the version test on real transactions#
All three formats show up in a first decode from raw shreds, and the decoding docs cover each language.
Sources#
- Solana docs: versioned transactions (checked 2026-11-18)
- anza-xyz/solana-sdk message/src/versions/mod.rs (MESSAGE_VERSION_PREFIX = 0x80) (checked 2026-11-18)
- Solana improvement document 0385, the v1 transaction layout (checked 2026-11-18)
- Agave v4.4.1 feature-set: enable_tx_v1 (SIMD-0385) (checked 2026-11-18)
- Mainnet getBlock, slots 470,901,815 and 470,901,816: 178 legacy, 331 v0 and 272 v1 transactions (checked 2026-11-18)
Raw shreds on your own server
Ultra Low Latency Shreds is $200 and Standard Shreds is $100. You pay in crypto, tell us which IPv4 address and UDP port should receive the stream, and we wire it up by hand.