1. Transaction Manifest Language

What is a Transaction Manifest?

A transaction manifest is a human-readable script that describes exactly what a transaction does – which assets move where, which components are called, and in what order. Unlike EVM bytecode, manifests are transparent: the Radix Wallet summarizes them in plain language so users never "blind sign."

Manifests use a bash-like syntax where each instruction is a command followed by typed arguments and a semicolon. Instructions execute sequentially – if any fails, the entire transaction rolls back atomically.

The Worktop

Every transaction has a worktop – a temporary holding area for resources in transit. When you withdraw tokens from an account, they land on the worktop. You then take them into named buckets and pass them to methods or deposit them.

# Withdraw 10 XRD — tokens land on worktop
CALL_METHOD Address("account_rdx...") "withdraw"
  Address("resource_rdx1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxradxrd")
  Decimal("10")
;
 
# Take from worktop into a named bucket
TAKE_FROM_WORKTOP
  Address("resource_rdx1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxradxrd")
  Decimal("10")
  Bucket("xrd_bucket")
;

Core Instructions

Value Types

• Address("resource_rdx...") – entity addresses
• Decimal("10.5") – numeric amounts
• Bucket("name") – named bucket references
• Proof("name") – named proof references
• Expression("ENTIRE_WORKTOP") – deposit everything remaining

Addresses carry their network, and the checksum is checked first

Every address in a manifest names one network, and a manifest may only reference one network at a time. The prefix tells you which: account_rdx1... and resource_rdx1... are Mainnet, while Stokenet uses account_tdx_2_1... and resource_tdx_2_1..., and the local simulator uses _sim1.... XRD therefore has a different address on each one:

The three look almost identical, and the last six characters are the Bech32m checksum, so swapping one prefix for another without recomputing the rest produces an address that no tool will accept. This fails early rather than quietly: the Radix Engine Toolkit rejects the manifest at parse time with an InvalidGlobalAddress error naming the offending address, and the wallet never sees it. Paste an address you are unsure about into the Developer Console or a Gateway lookup before you build a manifest around it.

Common Patterns

Simple Token Transfer

CALL_METHOD Address("account_rdx_sender...") "lock_fee" Decimal("5");
 
CALL_METHOD Address("account_rdx_sender...") "withdraw"
  Address("resource_rdx1tk...xrd...")
  Decimal("100")
;
 
TAKE_ALL_FROM_WORKTOP Address("resource_rdx1tk...xrd...") Bucket("tokens");
 
CALL_METHOD Address("account_rdx_recipient...") "try_deposit_or_abort"
  Bucket("tokens") Enum<0u8>()
;

DEX Swap with Slippage Protection

CALL_METHOD Address("account_rdx...") "withdraw"
  Address("token_a_addr") Decimal("100")
;
 
TAKE_ALL_FROM_WORKTOP Address("token_a_addr") Bucket("input");
 
CALL_METHOD Address("dex_component_addr") "swap"
  Bucket("input")
;
 
# Ensure minimum output — reverts if not met
ASSERT_WORKTOP_CONTAINS Address("token_b_addr") Decimal("95");
 
CALL_METHOD Address("account_rdx...") "deposit_batch"
  Expression("ENTIRE_WORKTOP")
;

Building Manifests Programmatically

While you can write manifests by hand, most dApps build them in code:

• TypeScript – the Radix dApp Toolkit sends manifests via sendTransaction
• Rust – the ManifestBuilder provides a fluent API
• Console – the Developer Console has a raw transaction editor

Next Steps

• Transaction Lifecycle – what happens between building a manifest and seeing it committed

External Links

• Complete instruction reference
• Manifest value syntax
• Simple token transfer example
• Rust ManifestBuilder