Transaction format

Each deshred_transaction update carries the slot and one transaction:

Field	Contents
`slot`	Slot the transaction was produced in
`transaction.signature`	First signature, 64 bytes; base58 it for the usual transaction id
`transaction.transaction`	The signed transaction as `solana.storage.ConfirmedBlock.Transaction`: `signatures` and `message`
`transaction.loaded_writable_addresses`	Writable addresses loaded from lookup tables, 32 bytes each
`transaction.loaded_readonly_addresses`	Read-only addresses loaded from lookup tables, 32 bytes each
`transaction.completed_data_set_starting_shred_index`, `..._ending_shred_index_exclusive`	Shred range of the data the transaction was decoded from
`created_at`	When the server sent the update

is_vote is always false: vote transactions are not sent.

Message

Field	Contents
`header`	Required signatures, read-only signed and read-only unsigned counts
`account_keys`	Static account keys, 32 bytes each; the first is the fee payer
`recent_blockhash`	The transaction’s recent blockhash (for v1, its lifetime hash)
`instructions`	`program_id_index`, `accounts` (one byte per account index) and `data`
`versioned`	`false` for legacy transactions
`address_table_lookups`	v0 only: the tables and indexes the transaction loads from
`config`	v1 only: priority fee, compute unit limit, loaded accounts data size limit and heap size, when set

Transaction version

`versioned`	`config`	Version
`false`	absent	legacy
`true`	absent	v0
`true`	present	v1

v1 transactions have no address table lookups.

Account indexes

Instruction account indexes and program_id_index point into one list:

account_keys,
then loaded_writable_addresses,
then loaded_readonly_addresses.

This is the same order the runtime uses, so you can resolve every instruction account without reading any lookup table yourself. Program ids are always static keys. If a transaction’s lookup tables could not be resolved, both loaded lists are empty while address_table_lookups is not. Indexes past account_keys are then unknown; treat the transaction as incomplete rather than guessing.

Reading it

let message = info.transaction.as_ref().and_then(|t| t.message.as_ref()).unwrap();
let keys: Vec<&[u8]> = message
    .account_keys
    .iter()
    .chain(&info.loaded_writable_addresses)
    .chain(&info.loaded_readonly_addresses)
    .map(Vec::as_slice)
    .collect();
for ix in &message.instructions {
    let program = bs58::encode(keys[ix.program_id_index as usize]).into_string();
    let accounts: Vec<String> = ix.accounts.iter().map(|&i| bs58::encode(keys[i as usize]).into_string()).collect();
    println!("{program} {accounts:?} {}B", ix.data.len());
}

const message = info.transaction!.message!;
const keys = [...message.accountKeys, ...info.loadedWritableAddresses, ...info.loadedReadonlyAddresses];
for (const ix of message.instructions) {
  const program = bs58.encode(keys[ix.programIdIndex]);
  const accounts = [...ix.accounts].map((i) => bs58.encode(keys[i]));
  console.log(program, accounts, `${ix.data.length}B`);
}

message := info.GetTransaction().GetMessage()
keys := slices.Concat(message.AccountKeys, info.LoadedWritableAddresses, info.LoadedReadonlyAddresses)
for _, ix := range message.Instructions {
	accounts := make([]string, len(ix.Accounts))
	for n, i := range ix.Accounts {
		accounts[n] = base58.Encode(keys[i])
	}
	fmt.Println(base58.Encode(keys[ix.ProgramIdIndex]), accounts, len(ix.Data), "B")
}

Get started

Plans

RPC

Yellowstone gRPC

Preplay Shreds

More products

APIs

Reference

Transaction format

Message

Transaction version

Account indexes

Reading it

​Message

​Transaction version

​Account indexes

​Reading it

Message

Transaction version

Account indexes

Reading it