05 Transactions

5.2 The Transaction Manifest in Practice

When it comes to understanding the transaction manifest, it’s easier to see it in action before we dive into concepts. So this section will go through a few interactive examples by sending a few transactions with a transaction manifest through a test network to get a clear picture how they work in practice. To do so we recommend that you:

Set up and install the Radix Wallet
Head over to the Developer Console
Make sure that the Radix Wallet Gateway is pointed to “Stokenet Gateway”
You can do this by going to your wallet Settings → App Settings → Gateways

Get some Test XRD tokens:

Create a New Account
Go to the Account Settings (three dots in the upper-right corner)
Go to Dev Preferences
Click on Get XRD Test Tokens

Once that’s completed, we can begin going through a few transaction manifest examples!

//Sending Tokens to Another Account

Once you have an account with some XRD test tokens, we are going to create another account to deposit 100 XRD test tokens.

We can send tokens between account by simply pasting in this transaction manifest to the Send Transaction Manifest within the Developer Console. Make sure to replace the the addresses within ${this_account_address} with accounts you've set up as well as the ResourceAddress you’d like to send.

To get the XRD test tokens ResourceAddress you can open your first account with the XRD test tokens and copy the ResourceAddress shown on the token.

1# Withdrawing 100 XRD from the account component2CALL_METHOD 3    Address("${this_account_address}") 4    "withdraw"5    Address("${xrd_resource_address}")6    Decimal("100");78# Depositing all of the XRD withdrawn from the account into the other account9CALL_METHOD10    Address("${other_account_address}") 11    "try_deposit_batch_or_abort"12    Expression("ENTIRE_WORKTOP")13    None;

Test XRD ResourceAddress is resource_tdx_2_1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxtfd2jc

This transaction manifest has two simple instruction which specifies two method calls of two different accounts. One instruction is to withdraw a specified resource and amount from one account and depositing it all to a second account.

//Multi Account Transfer

The transaction manifest can also batch multiple instructions; we do not need to have separate transaction manifest files for each individual actions. For example, in this transaction manifest file below, we can submit a transaction to send to multiple accounts with some funds from our account. We also have an instruction to manage resources in the worktop and make sure the bucket of resources are being moved to the right accounts.

Here you have 330 XRD in this_account_address and you will distribute the XRD into other accounts:

150 to account_address_a
130 to account_address_b
50 to account_address_c

1# Withdrawing 330 XRD from the account component2CALL_METHOD 3    Address("${this_account_address}") 4    "withdraw"5    Address("${xrd_resource_address}")6    Decimal("330");78# Taking 150 XRD from the worktop and depositing them into Account A9TAKE_FROM_WORKTOP10    Address("${xrd_resource_address}")11    Decimal("150")12    Bucket("account_a_bucket");13CALL_METHOD14    Address("${account_address_a}")15    "try_deposit_or_abort"16    Bucket("account_a_bucket")17    None;1819# Taking 130 XRD from the worktop and depositing them into Account B20TAKE_FROM_WORKTOP21    Address("${xrd_resource_address}")22    Decimal("130")23    Bucket("account_b_bucket");24CALL_METHOD25    Address("${account_address_b}")26    "try_deposit_or_abort"27    Bucket("account_b_bucket")28    None;2930# Taking 50 XRD from the worktop and depositing them into Account C31TAKE_FROM_WORKTOP32    Address("${xrd_resource_address}")33    Decimal("50")34    Bucket("account_c_bucket");35CALL_METHOD36    Address("${account_address_c}")37    "try_deposit_or_abort"38    Bucket("account_c_bucket")39    None;

Note that the name of Bucket() can be anything you choose.

//Creating a Fungible Resource

All throughout this course, we’ve shown how resources are created within Scrypto; but in fact, you don’t need Scrypto to create resources. You can create resources by sending a transaction manifest!

1# Creating a new resource with a divisibility of 18 and a name of `MyResource`. The resource has 2# default resource behavior where it can be withdrawn and deposited by anybody.3CREATE_FUNGIBLE_RESOURCE_WITH_INITIAL_SUPPLY4    # Owner role - This gets metadata permissions, and is the default for other permissions5    # Can set as Enum<OwnerRole::Fixed>(access_rule)  or Enum<OwnerRole::Updatable>(access_rule)6    Enum<OwnerRole::None>()7    true             # Whether the engine should track supply (avoid for massively parallelizable tokens)8    18u8             # Divisibility (between 0u8 and 18u8)9    Decimal("${initial_supply}") # Initial supply10    Tuple(11        Some(         # Mint Roles (if None: defaults to DenyAll, DenyAll)12            Tuple(13                Some(Enum<AccessRule::AllowAll>()),  # Minter (if None: defaults to Owner)14                Some(Enum<AccessRule::DenyAll>())    # Minter Updater (if None: defaults to Owner)15            )16        ),17        None,        # Burn Roles (if None: defaults to DenyAll, DenyAll)18        None,        # Freeze Roles (if None: defaults to DenyAll, DenyAll)19        None,        # Recall Roles (if None: defaults to DenyAll, DenyAll)20        None,        # Withdraw Roles (if None: defaults to AllowAll, DenyAll)21        None         # Deposit Roles (if None: defaults to AllowAll, DenyAll)22    )23    Tuple(                                                                   # Metadata initialization24        Map<String, Tuple>(                                                  # Initial metadata values25            "name" => Tuple(26                Some(Enum<Metadata::String>("MyResource")),                  # Resource Name27                true                                                         # Locked28            )29        ),30        Map<String, Enum>(                                                   # Metadata roles31            "metadata_setter" => Some(Enum<AccessRule::AllowAll>()),         # Metadata setter role32            "metadata_setter_updater" => None,                               # Metadata setter updater role as None defaults to OWNER33            "metadata_locker" => Some(Enum<AccessRule::DenyAll>()),          # Metadata locker role34            "metadata_locker_updater" => None                                # Metadata locker updater role as None defaults to OWNER35        )36    )37    None;             # No Address Reservation3839# Depositing the entirety of the initial supply of the newly created resource into our account 40# component.41CALL_METHOD42    Address("${account_address}") 43    "deposit_batch"44    Expression("ENTIRE_WORKTOP");

There’s quite a bit going on here, but I’ve highlighted the key areas where you’d want to input for this transaction manifest to work. There are various comments to each instruction input if you’re curious to do your own configuration, but we’ll go over those more in detail. For now, we’re simply getting a feel to how transaction manifest work.

//Minting Supply of Existing Fungible Resource

So long as we have the badge that has permissions to mint a resource, the transaction manifest also have instructions to mint supply of a resource.

1# Instruction to create a proof of a badge with minting permission.2# Only needed if `minter` requires a badge.3CALL_METHOD4    Address("${account_address}")5    "create_proof_of_amount"6    Address("${minter_badge_resource_address}")7    Decimal("1");89# Minting some amount of tokens from the mintable fungible resource10MINT_FUNGIBLE 11    Address("${mintable_fungible_resource_address}")12    Decimal("${mint_amount}");1314# Depositing the entirety of the newly minted tokens into out account15CALL_METHOD16    Address("${account_address}") 17    "deposit_batch"18    Expression("ENTIRE_WORKTOP");

//Creating a NonFungible Resource

Here’s a similar transaction manifest instruction to create and mint a non-fungible resource. Again, quite a bit going on, but we’ll get through it in due time. We can simply copy and paste this in and input our own values in the highlighted lines.

1# Creating a new resource 2CREATE_NON_FUNGIBLE_RESOURCE_WITH_INITIAL_SUPPLY3    # Owner role - This gets metadata permissions, and is the default for other permissions4    # Can set as Enum<OwnerRole::Fixed>(access_rule)  or Enum<OwnerRole::Updatable>(access_rule)5    Enum<OwnerRole::None>()6    Enum<NonFungibleIdType::Integer>()                                                                  # The type of NonFungible Id7    true                                                                                                # Whether the engine should track supply (avoid for massively parallelizable tokens)8    Enum<0u8>(Enum<0u8>(Tuple(Array<Enum>(), Array<Tuple>(), Array<Enum>())), Enum<0u8>(66u8), Array<String>())     # Non Fungible Data Schema9    Map<NonFungibleLocalId, Tuple>(                                                                     # Initial supply to mint10        NonFungibleLocalId("${non_fungible_local_id}") => Tuple(Tuple())  # Since NonFungibleIdType is an integer, the number must be enclosed in numeric characters, such as NonFungibleLocalId("#1#")11    )12    Tuple(13        Some(         # Mint Roles (if None: defaults to DenyAll, DenyAll)14            Tuple(15                Some(Enum<AccessRule::AllowAll>()),  # Minter (if None: defaults to Owner)16                Some(Enum<AccessRule::DenyAll>())    # Minter Updater (if None: defaults to Owner)17            )18        ),19        None,        # Burn Roles (if None: defaults to DenyAll, DenyAll)20        None,        # Freeze Roles (if None: defaults to DenyAll, DenyAll)21        None,        # Recall Roles (if None: defaults to DenyAll, DenyAll)22        None,        # Withdraw Roles (if None: defaults to AllowAll, DenyAll)23        None,        # Deposit Roles (if None: defaults to AllowAll, DenyAll)24        None         # Non Fungible Data Update Roles (if None: defaults to DenyAll, DenyAll)25    )26    Tuple(                                                                   # Metadata initialization27        Map<String, Tuple>(                                                  # Initial metadata values28            "name" => Tuple(29                Some(Enum<Metadata::String>("MyResource")),                  # Resource Name30                true                                                         # Locked31            )32        ),33        Map<String, Enum>(                                                   # Metadata roles34            "metadata_setter" => Some(Enum<AccessRule::AllowAll>()),         # Metadata setter role35            "metadata_setter_updater" => None,                               # Metadata setter updater role as None defaults to OWNER36            "metadata_locker" => Some(Enum<AccessRule::DenyAll>()),          # Metadata locker role37            "metadata_locker_updater" => None                                # Metadata locker updater role as None defaults to OWNER38        )39    )40    None;             # No Address Reservation4142# Depositing the entirety of the initial supply of the newly created resource into our account 43# component.44CALL_METHOD45    Address("${account_address}") 46    "deposit_batch"47    Expression("ENTIRE_WORKTOP");

//Minting Supply of Existing NonFungible Resource

Similarly, the transaction manifest also has an instruction to mint non-fungible resources as well.

1# Instruction to create a proof of a badge with minting permission.2# Only needed if `minter` requires a badge.3CALL_METHOD4    Address("${account_address}")5    "create_proof_of_amount"6    Address("${minter_badge_resource_address}")7    Decimal("1");89# Minting a single non-fungible token from the resource. This non-fungible token has no data.10MINT_NON_FUNGIBLE11    Address("${mintable_non_fungible_resource_address}")12    Map<NonFungibleLocalId, Tuple>(13        NonFungibleLocalId("${non_fungible_local_id}") => Tuple(Tuple())14    );1516# Depositing the entirety of the newly minted tokens into out account17CALL_METHOD18    Address("${account_address}") 19    "deposit_batch"20    Expression("ENTIRE_WORKTOP");

//Generating Transaction Manifest files with Resim

There are of course more instructions a transaction manifest has. You can find a list of instructions which you may copy and paste to the console to test yourself in the documentation. However, this is just to get a flavor of how transaction manifest works. You can also run transaction manifest files using resim. In fact, resim is either generating and running transaction manifest under the hood with every command we input.

You can see this for yourself by creating a new account in resim (if you haven’t already) and inputting the command resim new-token-fixed 1000 --manifest new_token.rtm which will create a manifest file in the directory your terminal is in titled new_token.rtm. If you open that file in a text editor, it will look something like this:

1CALL_METHOD2    Address("component_sim1cptxxxxxxxxxfaucetxxxxxxxxx000527798379xxxxxxxxxhkrefh")3    "lock_fee"4    Decimal("5000")5;6CREATE_FUNGIBLE_RESOURCE_WITH_INITIAL_SUPPLY7    Enum<0u8>()8    true9    18u810    Decimal("1000")11    Tuple(12        Enum<0u8>(),13        Enum<0u8>(),14        Enum<0u8>(),15        Enum<0u8>(),16        Enum<0u8>(),17        Enum<0u8>()18    )19    Tuple(20        Map<String, Tuple>(),21        Map<String, Enum>()22    )23    Enum<0u8>()24;25CALL_METHOD26    Address("account_sim1c956qr3kxlgypxwst89j9yf24tjc7zxd4up38x37zr6q4jxdx9rhma")27    "try_deposit_batch_or_refund"28    Expression("ENTIRE_WORKTOP")29    Enum<0u8>()30;

Of course, it’ll the transaction manifest file will have your own account address. Although, you’ll notice that there’s an additional CALL_METHOD instruction to lock_fee. We’ll get into that in due time.

We haven’t actually ran this manifest file yet. The resim command we inputted only generated a transaction manifest file. To run the file we’ll need to input resim run new_token.rtm which will process the transaction to create and mint your tokens!

//Reference Material

Transaction ManifestManifest InstructionsGithub: Transaction manifest examples

5.1 Summary

5.2 Summary