---
title: "1. Transaction Manifest Language"
url: "https://radix.wiki/developers/transactions/01-manifest-language"
version: "2.0.0"
updated: 2026-08-25
last_verified: 2026-08-25
license: CC-BY-4.0
license_url: "https://creativecommons.org/licenses/by/4.0/"
---

# 1. Transaction Manifest Language

## What is a Transaction Manifest?

A [transaction manifest](https://docs.radixdlt.com/docs/learning-to-create-and-use-transaction-manifests) 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](/contents/tech/core-protocols/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](https://docs.radixdlt.com/docs/resources)** and pass them to methods or deposit them.

```rust
# 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

| Instruction | Purpose |
| --- | --- |
| `CALL_METHOD` | Call a method on a component (e.g., withdraw, deposit, swap) |
| `CALL_FUNCTION` | Call a function on a blueprint (e.g., instantiate) |
| `TAKE_FROM_WORKTOP` | Take a specific amount from worktop into a bucket |
| `TAKE_ALL_FROM_WORKTOP` | Take all of a resource from worktop into a bucket |
| `ASSERT_WORKTOP_CONTAINS` | Assert minimum amount on worktop (slippage protection) |
| `CREATE_PROOF_FROM_BUCKET_OF_AMOUNT` | Create an authorization proof from a bucket |

### 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:

| Network | XRD resource address |
| --- | --- |
| Mainnet | `resource_rdx1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxradxrd` |
| [Stokenet](/contents/tech/releases/stokenet) | `resource_tdx_2_1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxtfd2jc` |
| Simulator (`resim`) | `resource_sim1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxakj8n3` |

The three look almost identical, and the last six characters are the [Bech32m](https://en.bitcoin.it/wiki/Bech32) 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](/developers/transactions/04-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](https://console.radixdlt.com) or a [Gateway](/contents/tech/core-protocols/radix-gateway-api) lookup before you build a manifest around it.

## Common Patterns

### Simple Token Transfer

```rust
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()
;
```

### DEX Swap with Slippage Protection

```rust
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")
;
```

Atomic composability

You can chain calls to multiple components in one manifest. If a DEX swap feeds into a lending protocol deposit, both succeed or both fail – no partial state.

## Building Manifests Programmatically

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

- **TypeScript** – the [Radix dApp Toolkit](/developers/frontend/01-radix-dapp-toolkit) sends manifests via `sendTransaction`
- **Rust** – the [ManifestBuilder](https://docs.radixdlt.com/docs/rust-manifest-builder) provides a fluent API
- **Console** – the [Developer Console](https://console.radixdlt.com) has a raw transaction editor

## Next Steps

- [Transaction Lifecycle](/developers/transactions/02-transaction-lifecycle) – what happens between building a manifest and seeing it committed

## External Links

- [Complete instruction reference](https://docs.radixdlt.com/docs/manifest-instructions)
- [Manifest value syntax](/contents/tech/core-protocols/transaction-manifests)
- [Simple token transfer example](https://docs.radixdlt.com/docs/simple-token-transfer)
- [Rust ManifestBuilder](https://docs.radixdlt.com/docs/rust-manifest-builder)