Solana address lookup tables are on-chain accounts that store up to 256 addresses, so a v0 transaction can name an account with a one-byte index instead of 32 bytes. The transaction carries only the table's address and the indexes. To learn which accounts it touches, a decoder must read the table account itself.
What a lookup table is#
A lookup table is an account owned by the Address Lookup Table program, AddressLookupTab1e1111111111111111111111111. Its data starts with 56 bytes of metadata and continues with a plain list of 32-byte addresses. Its authority can append addresses with an extend instruction, up to 256 in total, and can later deactivate and close it. Nobody can reorder or overwrite the addresses already there.
Senders use tables to fit more accounts into a transaction than the 1,232-byte limit would otherwise allow. Swap routes through several pools are the typical case.
What the transaction carries: indexes, not addresses#
A v0 message ends with a list of lookups. Each lookup has three parts: the table's address, a list of indexes for accounts the transaction may write, and a list of indexes for accounts it only reads. Every index is a single byte pointing into that table's address list.
So the transaction tells you which table and which positions, never which accounts. The addresses live only in the table account's data, and whether each one is writable is set by which list its index sits in.
Resolution order#
- Take the static account keys from the message, in order.
- For each lookup, in the order they appear, read the writable indexes from that table and append the addresses.
- Then, again for each lookup in order, read the readonly indexes and append those addresses.
- Use the combined list for every instruction's account indexes. Position 0 is still the fee payer.
All writable lookups come before all readonly lookups, across every table, not table by table. Getting that wrong shifts every looked-up account and silently mislabels the instruction's accounts. The roles that result are covered in account roles.
A real v0 transaction, resolved#
This transaction from mainnet slot 470,901,816 uses two tables.
| Part of the account list | Where it comes from | Count |
|---|---|---|
| Positions 0 to 20 | Static keys inside the transaction | 21 |
| Positions 21 to 23 | Writable indexes in table A | 3 |
| Positions 24 to 35 | Readonly indexes in table A | 12 |
| Positions 36 to 39 | Readonly indexes in table B | 4 |
Nineteen of its forty accounts are not written anywhere in the transaction. Across the two blocks we sampled, 95 of 331 v0 transactions used at least one table, one used six, and several tables in use were already full at 256 addresses. Resolving each transaction the way the steps above describe reproduced the loadedAddresses that RPC reports for all 331 of them.
Tables change: extend, deactivate, close#
Tables are not frozen, and three rules govern what a decoder can rely on.
Extending. New addresses go on the end. Addresses added in the same slot as a transaction are not usable by that transaction; the table metadata records the last extended slot and the length before that extension for exactly this check. Because existing positions never move, a copy of the table you fetched later still gives the right answer for older indexes.
Deactivating. The authority can mark a table deactivated. It stays usable until its deactivation slot drops out of the SlotHashes sysvar, which keeps the 512 most recent entries. After that it is fully deactivated.
Closing. Only a fully deactivated table can be closed, and then its account disappears. A transaction that used it before closing can no longer be resolved from current state; you need a copy you saved earlier, or the loadedAddresses RPC kept with the transaction.
v1 transactions do not use lookup tables#
The v1 format has no lookups. Every account a v1 transaction uses is written inside it, and its size limit of 4,096 bytes leaves room for them. If your traffic shifts toward v1, the share of transactions that need table state falls.
Program IDs never come from tables in any format. The v0 message rules reject a program index that points past the static keys, so you can always tell which programs a transaction calls without resolving anything.
Why lookups land on you when you decode from shreds#
A shred decoder sees the transaction long before RPC can show resolved addresses, which is the point of using shreds. The price is that resolution falls on you: keep a cache of table contents, refresh a table when an index points past its known length, and fetch tables you have never seen. Resolving lookup tables when you decode from shreds builds that cache in code, and the lookup table problem discusses its failure cases.
Questions about lookup tables#
Can a program ID come from a lookup table?#
No. The v0 message rules require every instruction's program to be one of the static keys.
Does a table's content change under me?#
Only by growing. Existing positions keep their addresses until the table is closed, so a cached table stays correct for the indexes it already holds.
Do parsed APIs resolve tables for me?#
Yes, they hand you resolved accounts, at the cost of seeing the transaction later. The trade-off is in the parsed API comparison.
What you cannot recover without table state#
Without the table's data, a v0 transaction's looked-up accounts are only numbers. You can still see its programs and its static accounts, but not which pool, token account or user the lookups point to. For a table that was closed before you fetched it, only a source that saved the resolution at the time can fill the gap.
Resolve tables in practice#
To try the full path from shreds to resolved accounts, the first-decode walkthrough is the place to start. The decoding pipeline shows where resolution sits among the other stages, and the decoder recipes by language and program cover the rest.
Sources#
- Solana docs: address lookup tables (checked 2026-11-18)
- anza-xyz/solana-sdk address-lookup-table-interface src/state.rs (meta 56 bytes, max 256 addresses, active length, deactivation status) (checked 2026-11-18)
- anza-xyz/solana-sdk slot-hashes: MAX_ENTRIES = 512 (checked 2026-11-18)
- anza-xyz/solana-sdk message v0: program ids cannot come from lookup tables (checked 2026-11-18)
- SIMD-0385 Transaction V1 Format: no address lookup tables (checked 2026-11-18)
- Mainnet getBlock slots 470,901,815 and 470,901,816 with meta.loadedAddresses; example 3QveEtZR7cN6PomYshG9CLo4miPFGWyxmRXWvpSgAe3VtusQvH776Kk9vkP6gptoVwtk6m5r37ZytCztj98HZGRW (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.