Radix Transactions and Manifests

This section is the developer guide to Radix transactions: how to write a manifest, how a transaction is built, signed and submitted, what it costs, and the tools that build one outside the network.

What is a Radix transaction manifest?

A transaction manifest is the list of instructions inside every Radix transaction: a human-readable sequence of component calls and movements of resources between components, which the Radix Engine executes atomically, so either all of it takes effect or none of it does. Because it is readable, the Radix Wallet can show a user what they are signing before the manifest is translated into binary, signed and sent to the network (Radix docs: Manifest).

Besides calls and transfers, a manifest can present badges to authorize a call, pay the transaction fee, and check resource amounts, so the user receives a guaranteed result or the transaction fails (Manifest). How this differs from signing EVM calldata is covered under blind signing.

How is a manifest put together?

Each instruction is a command, zero or more arguments and a semicolon (Manifest Instructions). This one, from the docs and written against the simulator network's $XRD, creates a bucket named xrd_bucket holding 1 $XRD taken from the worktop:

TAKE_FROM_WORKTOP
    Address("resource_sim1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxakj8n3")
    Decimal("1.0")
    Bucket("xrd_bucket")
;

A manifest is one part of an intent, which adds a header and an optional message; the manifest can also carry blobs, byte payloads passed into calls, and the hashes of child subintents (Manifest). A transaction holds one transaction intent and zero or more subintents, each with its own manifest and signatures, and together they form a tree with the transaction intent at the root (Intent Structure). A subintent hands control and buckets back to its parent with YIELD_TO_PARENT, and every subintent must end with one, so a transaction that succeeds has run every subintent in full.

The guides in this section

1. Transaction Manifest Language: the instruction syntax, the worktop, and how instructions run in order and roll back together.
2. Transaction Lifecycle: the three layers from intent to signed intent to notarized transaction, and what the header sets.
3. Transaction Fees: why the fee is paid by whichever component locks it, and how network cost, tip and royalties add up.
4. Radix Engine Toolkit: the off-ledger library, with wrappers for TypeScript, Python, Swift, C# and Kotlin, that builds, signs and inspects transactions.
5. Addresses and Entity Types: how a Radix address names its entity type and network in its prefix.
6. SBOR: the value model and byte encoding behind every payload, and how to write values in a manifest.
7. Building Transactions in Rust: build, notarize and submit a V2 transaction, with a subintent, using radix-transactions.

The reference article on transaction manifests lists the full instruction set by group.

External Links

• Transactions & Manifests – Radix documentation
• Manifest Instructions – every instruction, with compilable examples
• Transaction Overview – user, ledger and validator transactions
• Intent Structure – the intent tree and its limits