Shreds carry no inner instructions, no logs, no balances and no execution status. A shred holds pieces of the signed transactions a leader put in its block, before anything ran. Every field the runtime produces while executing, from the error code to the compute units used, arrives later through RPC or a Geyser stream.
The RPC fields you will not find, one by one#
When you call getTransaction, the response has two halves: the transaction you also get from shreds, and a meta object that replay creates. The second half is the blind spot. Here is each field, why it is absent, and what you can do instead.
meta field | Why shreds lack it | Closest thing you can do |
|---|---|---|
err / status | only execution knows whether it failed | mark the row provisional, check status later |
fee | charged at execution | compute it: 5,000 lamports per signature, counting signatures checked by precompile instructions, plus the declared priority fee |
preBalances / postBalances | balances are account state after replay | read declared amounts from instruction data, confirm later |
preTokenBalances / postTokenBalances | same, for token accounts | same, and look up mint decimals |
logMessages | written by programs while running | none from shreds |
innerInstructions | calls made by programs while running | infer from the outer program and your knowledge of it |
loadedAddresses | expanded by the runtime from lookup tables | resolve the tables yourself from account state |
returnData | produced by the last program to set it | none from shreds |
computeUnitsConsumed | measured during execution | the declared limit is in the transaction, the usage is not |
Two rows stand out because you can rebuild them. The fee is fully determined by the transaction: a base of 5,000 lamports per signature, counting the signatures that Ed25519, secp256k1 and secp256r1 precompile instructions verify (E4 tech facts T-10), plus the priority fee, which legacy and v0 transactions declare through Compute Budget instructions (tag 2 sets the unit limit, tag 3 the price) and v1 transactions declare in their config mask. The looked-up addresses can be rebuilt from lookup table accounts. Everything else waits for replay.
Inner instructions: why a routed swap looks like one call#
A program can call other programs while it runs. Those cross-program invocations are recorded as inner instructions, and they exist only after execution. In the raw transaction, an aggregator swap is a single outer instruction to the aggregator, with its route encoded in the data. The token transfers on each pool it touches are inner instructions, so a shred-based decoder never sees them.
What you can read is intent: the input amount, the slippage limit and the accounts passed in. What you cannot read is the path the money actually took or the amount that came out. Treat outer instruction data as the trader's request, not as a trade report.
Events sent through logs or a self CPI#
Anchor programs publish events in two ways, and neither reaches a raw decoder:
emit!writes the event through the logging syscall, so it appears as a "Program data:" log line, which is part of the missinglogMessages.emit_cpi!makes the program call itself with the event as instruction data. That is an inner instruction, so it is missing too.
If a program's useful information lives only in its events, raw shreds will not give it to you. If the same information is in the instruction arguments, it will.
When the blind spots do not matter#
Many products run on intent, not outcomes:
- Watching for activity. "Wallet X just signed a transfer to Y" needs the signer, the program and the arguments. All three are in the transaction.
- Spotting new markets or tokens. A pool or mint creation instruction names the new accounts in its own data and account list.
- Pricing priority fees. The declared unit price and limit are in the transaction, so you can see what others are bidding.
- Early warnings that you confirm later. Show the event as pending, then upgrade or drop it.
When you need a second source#
You need execution data when the product depends on what actually happened:
- Balances and portfolio values. Post-balances come from replay.
- Realised swap prices and volumes. The amount out is an inner transfer.
- Program-specific events. If the program reports through logs or self CPIs, read them from RPC.
- Failure-sensitive counts. A failed transaction still lands in the block and still pays its fee.
The usual design is to decode from shreds for the early signal, then join each row to its RPC result by signature once the slot is confirmed, as the reconcile step shows.
Short answers on shred data limits#
Do Solana shreds include inner instructions?#
No. Inner instructions are created while programs execute, and shreds carry transactions before execution. Only outer instructions are present.
Can I get program logs from shreds?#
No. Logs are written during execution and returned in the transaction's metadata by RPC or a Geyser stream.
Can I tell from shreds whether a transaction succeeded?#
No. Status is an execution result. You can only flag the row as unconfirmed and check it later.
Is anything in the metadata recoverable without RPC?#
The fee is, because it follows from the transaction's signatures, any signatures its precompile instructions verify, and the declared priority fee. Looked-up addresses can be rebuilt from lookup table accounts, which still means reading account state from somewhere.
What raw shreds cannot do for you#
Raw shreds are the right source for early, signed intent. They are the wrong source when a product must show final balances, realised prices or event logs at the moment it displays a row, or when a team cannot run a reconcile step at all. In those cases a stream of executed transactions or a parsed API carries the fields you need, at the cost of arriving after replay.
Where to read next#
The mechanics of program-to-program calls are in inner instructions and CPI, and the split between outputs and inputs is in logs versus instruction data. How programs emit events covers both event styles. For the failure case, read transactions that land but fail, and to weigh a hosted alternative, see parsed transaction APIs. If signed intent is what your product runs on, our two plans start at $100.
For the full list of stages between a packet and a usable row, start with why packets are not yet data.
Sources#
- Agave v4.4.1 entry struct: an entry holds only num_hashes, hash and transactions (checked 2026-11-18)
- solana-transaction-status 4.4.1, TransactionStatusMeta (status, fee, balances, logs, inner instructions, loaded addresses, return data, compute units) (checked 2026-11-18)
- Anchor event attribute: emit! writes through sol_log_data, emit_cpi! is a self CPI (checked 2026-11-18)
- Solana improvement document 0385, the v1 transaction layout (checked 2026-11-18)
- Compute Budget program interface (instruction tags 2 and 3) (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.