Radix DLT

https://docs.radixdlt.com/docs/
Admin
Radix is a Layer-1 decentralized finance platform with a focus on mainstream adoption, featuring the...
Tokens:250,579
Snippets:2,825
Trust Score:9.7
Update:4 months ago
Show doc for...
Tokens:
Raw
### Install Monitoring Services

Source: https://docs.radixdlt.com/docs/node-setting-up-grafana

After configuring the monitoring setup, run this command to install and activate the monitoring services.

```bash
babylonnode monitoring install
```

--------------------------------

### Advanced Monitoring Configuration

Source: https://docs.radixdlt.com/docs/node-setting-up-grafana

Select the DETAILED setup mode to be guided through a series of questions for a comprehensive monitoring configuration. This is suitable for use cases beyond the standard Core or Core & Gateway setups.

```bash
babylonnode monitoring config \
    -m DETAILED
```

--------------------------------

### Install RNG Tools for SSL Generation

Source: https://docs.radixdlt.com/docs/node-setup-systemd

Installs the 'rng-tools' package and starts the 'rngd' service to improve entropy for SSL key generation if needed.

```bash
sudo apt install rng-tools  

```

```bash
sudo rngd -r /dev/random  

```

--------------------------------

### Install Nginx and Utilities

Source: https://docs.radixdlt.com/docs/node-setup-systemd

Installs Nginx and Apache utilities on Ubuntu. This is the first step in setting up Nginx.

```bash
sudo apt install -y nginx apache2-utils  

```

--------------------------------

### Import Test Module Example

Source: https://docs.radixdlt.com/docs/learning-to-explain-your-first-test

Example of how to import the test version of a blueprint from a different package.

```rust
use example_package::example_blueprint_test::*  
```

--------------------------------

### CallMethod Example in C#

Source: https://docs.radixdlt.com/docs/radix-engine-toolkit-manifest-builder

This C# snippet shows how to use CallMethod to get free XRD from a faucet and deposit it into an account. It demonstrates calling the 'free' method on the faucet component and 'try_deposit_or_abort' on the account component.

```C#
using RadixEngineToolkit;
using static RadixEngineToolkit.RadixEngineToolkitUniffiMethods;
using Decimal = RadixEngineToolkit.Decimal;

const byte networkId = 0x02;
using var xrd = KnownAddresses(networkId).resourceAddresses.xrd;
using var faucet = KnownAddresses(networkId).componentAddresses.faucet;

using var account =
    new Address("account_tdx_2_168e8u653alt59xm8ple6khu6cgce9cfx9mlza6wxf7qs3wwdyqvusn");

using var manifest = new ManifestBuilder()
    .CallMethod(
        new ManifestBuilderAddress.Static(faucet), // <1>
        "free",
        new ManifestBuilderValue[] { } // <2>
    )
    .TakeFromWorktop(xrd, new Decimal("10000"), new ManifestBuilderBucket("xrd"))
    .CallMethod(
        new ManifestBuilderAddress.Static(account), // <1>
        "try_deposit_or_abort",
        new ManifestBuilderValue[] // <2>
        {
            new ManifestBuilderValue.BucketValue(new ManifestBuilderBucket("xrd")),
            new ManifestBuilderValue.EnumValue(0, new ManifestBuilderValue[] { }) // <3>
        })
    .Build(networkId);

manifest.StaticallyValidate();

```

--------------------------------

### Install wget and curl

Source: https://docs.radixdlt.com/docs/node-setup-guided-installing-cli

Install wget and curl if they are not already present on your system. These are needed for downloading files.

```bash
sudo apt install wget curl  

```

--------------------------------

### Install Radix CLI Tools

Source: https://docs.radixdlt.com/docs/coverage-tool

Installs the Radix CLI tools, including the coverage functionality, using Cargo. Ensure you have Rust and Cargo installed.

```bash
cargo install --force radix-clis@1.2.0  

```

--------------------------------

### Clone the Official Examples Repository

Source: https://docs.radixdlt.com/docs/learning-to-build-a-gumball-machine

Clone the repository containing the Scrypto examples, including the gumball machine.

```bash
git clone https://github.com/radixdlt/official-examples.git  

```

--------------------------------

### Install Systemd Dependencies

Source: https://docs.radixdlt.com/docs/node-setup-guided-installing-node

Run this command to install necessary software for systemd mode on a new host machine.

```bash
babylonnode systemd dependencies  

```

--------------------------------

### Install Radix CLI (Windows/macOS)

Source: https://docs.radixdlt.com/docs/getting-rust-scrypto

Installs the Radix Engine Simulator and command-line tools. Replace 1.3.0 with the required version.

```bash
cargo install --force radix-clis@1.3.0  

```

--------------------------------

### Install Docker Dependencies

Source: https://docs.radixdlt.com/docs/node-setup-guided-installing-node

Run this command to install necessary dependencies for Docker mode when setting up a new host machine.

```bash
babylonnode docker dependencies  

```

--------------------------------

### Nginx Node Details Response Example

Source: https://docs.radixdlt.com/docs/node-setup-systemd

Example JSON response from the '/system/identity' endpoint, showing node details.

```json
{
  "node_address": "node_...",
  ...
}

```

--------------------------------

### Url Metadata Example

Source: https://docs.radixdlt.com/docs/entity-metadata

Example of using Url datatypes in metadata, with fixed fields for info and icon URLs.

```rust
.metadata(metadata! {
    init {
        "info_url" => Url::of("https://tokens.radixdlt.com"), fixed;
        "icon_url" => Url::of("https://assets.radixdlt.com/icons/icon-xrd-32x32.png"), fixed;
    }
})

```

--------------------------------

### Install Wget and Unzip

Source: https://docs.radixdlt.com/docs/node-setup-systemd

Installs the wget and unzip utilities, which are necessary for downloading and extracting the Radix node software. This command is for Ubuntu systems.

```bash
# install wget and unzip if they don't come preinstalled on your system
sudo apt install wget unzip
```

--------------------------------

### Move Node Files to Installation Directory

Source: https://docs.radixdlt.com/docs/node-setup-systemd

Create the target directory and move the extracted node binaries and libraries. This ensures a clean and organized installation.

```bash
sudo mkdir -p /opt/radixdlt/babylon-node
sudo mv core-v1.2.1 /opt/radixdlt/babylon-node
sudo mv libcorerust.so /opt/radixdlt/babylon-node
```

--------------------------------

### Install Python Radix Engine Toolkit using pip

Source: https://docs.radixdlt.com/docs/radix-engine-toolkit-installation

Install the Python Radix Engine Toolkit from PyPi using the `pip install` command. Note that `pip3`, `python -m pip`, or `python3 -m pip` might be necessary depending on your environment.

```bash
pip install radix-engine-toolkit  

```

--------------------------------

### Get LLVM Installation Path (macOS)

Source: https://docs.radixdlt.com/docs/getting-rust-scrypto

Retrieves the installation path for LLVM version 18. Replace 18 with the required version.

```bash
# Replace 18 with the required version  
brew --prefix llvm@18  

```

--------------------------------

### Create Keystore Directory and Set Ownership

Source: https://docs.radixdlt.com/docs/node-setup-systemd

Prepare the directory for the node's keystore file, which contains the private key. Set the correct ownership for security.

```bash
sudo mkdir -p /srv/radixdlt/babylon-mainnet/data
sudo chown -R radixdlt:radixdlt /srv/radixdlt
```

--------------------------------

### Create and Deposit Bucket in Python

Source: https://docs.radixdlt.com/docs/radix-engine-toolkit-manifest-builder

Shows how to create a bucket named 'xrd_bucket' by taking XRD from the worktop and then depositing it into an account using the manifest builder. This example demonstrates the 'take_from_worktop' source method and the 'build' method (implicitly handling deposit).

```Python
from radix_engine_toolkit import *
  
network_id: int = 0x02  
xrd: Address = known_addresses(network_id).resource_addresses.xrd  
  
address: Address = Address(  
    "account_tdx_2_169ukwfsne0zvwrvsyk3mm3x7m6hggup52t6ng547m9a2qp6q5y99h8"  
)  
  
manifest: TransactionManifest = (  
    ManifestBuilder().faucet_free_xrd()  
    # The following is a source method that creates a bucket by taking a specified amount of  
    # resources from the worktop and into a bucket. The name to use for this bucket is `xrdBucket`.  
    # Any following method that wishes to refer to this bucket, it must refer to it using the name  
    # given to it here.  
    .take_from_worktop(xrd, Decimal("10000"), ManifestBuilderBucket("xrd_bucket"))  
    # The following is a sink method that consumes buckets by depositing them into an account. When  
    # wishing to refer to the bucket created by the previous method the same name that the bucket  
    # was created with is used again here.  
    .build(network_id)
)
```

--------------------------------

### Install Docker and Key Generation Tools

Source: https://docs.radixdlt.com/docs/node-setup-docker

Install Docker, Docker Compose, and random number generator tools. It also includes a command to set up the random number generator.

```bash
sudo apt install wget docker.io docker-compose rng-tools
# Setup the random number generator
sudo rngd -r /dev/random
```

--------------------------------

### String Hex to Data Extension

Source: https://docs.radixdlt.com/docs/radix-engine-toolkit-usage-guide

This Swift extension allows converting a hexadecimal string into Data. It is a utility required for several other examples in this guide.

```swift
import Foundation

extension String {
    func hexToData() -> Data? {
        var data = Data()
        var startIndex = self.startIndex
        while startIndex < self.endIndex {
            let endIndex = self.index(startIndex, offsetBy: 2)
            if let byte = UInt8(self[startIndex..<endIndex], radix: 16) {
                data.append(byte)
            } else {
                return nil // Invalid hex string
            }
            startIndex = endIndex
        }
        return data
    }
}
```

--------------------------------

### Create and Deposit Bucket in C#

Source: https://docs.radixdlt.com/docs/radix-engine-toolkit-manifest-builder

Demonstrates creating a bucket named 'xrdBucket' by taking XRD from the worktop and then depositing it into an account using the manifest builder. This showcases the source method 'TakeFromWorktop' and the sink method 'AccountTryDepositOrAbort'.

```C#
using static RadixEngineToolkit.RadixEngineToolkitUniffiMethods;  
using RadixEngineToolkit;  
using Decimal = RadixEngineToolkit.Decimal;  
  
const byte networkId = 0x02;  
var xrd = KnownAddresses(networkId).resourceAddresses.xrd  
  
using var address =  
    new Address("account_tdx_2_169ukwfsne0zvwrvsyk3mm3x7m6hggup52t6ng547m9a2qp6q5y99h8");  
  
using var manifest = new ManifestBuilder()  
    .FaucetFreeXrd()  
    // The following is a source method that creates a bucket by taking a specified amount of   
    // resources from the worktop and into a bucket. The name to use for this bucket is `xrdBucket`.  
    // Any following method that wishes to refer to this bucket, it must refer to it using the name  
    // given to it here.  
    .TakeFromWorktop(xrd, new Decimal("10000"), new ManifestBuilderBucket("xrdBucket"))  
    // The following is a sink method that consumes buckets by depositing them into an account. When  
    // wishing to refer to the bucket created by the previous method the same name that the bucket  
    // was created with is used again here.  
    .AccountTryDepositOrAbort(address, new ManifestBuilderBucket("xrdBucket"), null)  
    .Build(networkId);
```

--------------------------------

### CallMethod Example in Swift

Source: https://docs.radixdlt.com/docs/radix-engine-toolkit-manifest-builder

This Swift snippet demonstrates using CallMethod to get free XRD from a faucet and deposit it into an account. It shows the invocation of the 'free' method on the faucet and 'try_deposit_or_abort' on the account.

```Swift
import EngineToolkit
import Foundation

let networkId: UInt8 = 0x02
let xrd = knownAddresses(networkId: networkId).resourceAddresses.xrd
let faucet = knownAddresses(networkId: networkId).componentAddresses.faucet

let account = try! Address(address: "account_tdx_2_168e8u653alt59xm8ple6khu6cgce9cfx9mlza6wxf7qs3wwdyqvusn")

let manifest = try! ManifestBuilder()
    .callMethod(
        address: ManifestBuilderAddress.static(value: faucet), // <1>
        methodName: "free",
        args: [] // <2>
    )
    .takeFromWorktop(
        resourceAddress: xrd,
        amount: Decimal(value: "10000"),
        intoBucket: ManifestBuilderBucket(name: "xrd")
    )
    .callMethod(
        address: ManifestBuilderAddress.static(value: account), // <1>

```

--------------------------------

### Scrypto Component Ownership Example

Source: https://docs.radixdlt.com/docs/component-ownership

Demonstrates how to define and instantiate child components, and then how a parent component can own and interact with these child components. Note that the struct name automatically gets a 'Component' suffix when instantiated.

```rust
use scrypto::prelude::*;
  
#[blueprint]
mod child {
    struct Child {
        name: String,
    }

    impl Child {
        fn new_component(name: String) -> ChildComponent {
            Self {
                name
            }.instantiate()
        }

        pub fn get_name(&self) -> String {
            self.name.to_string()
        }
    }
}

#[blueprint]
mod parent {
    struct Parent {
        child0: ChildComponent,
        child1: ChildComponent,
    }

    impl Parent {
        fn new_component() -> ParentComponent {
            let child0: ChildComponent = Child::new("child0".to_string());
            let child1: ChildComponent = Child::new("child1".to_string());

            // Move the two child components into a new parent component
            let parent_component = Self {
                child0,
                child1,
            }.instantiate();

            // child0 and child1 are now owned by this parent_component
            parent_component
        }

        pub fn new_globalized() -> Global<Parent> {
            Self::new_component()
            .prepare_to_globalize(OwnerRole::None)
            .globalize()
        }

        pub fn get_child0_name(&self) -> String {
            self.child0.get_name()
        }

        pub fn get_child1_name(&self) -> String {
            self.child1.get_name()
        }
    }
}
```

--------------------------------

### Create Proof from Bucket of All Resources

Source: https://docs.radixdlt.com/docs/manifest-instructions

Creates a proof containing all resources present in a bucket. Requires taking all from worktop first.

```radix-instruction
TAKE_ALL_FROM_WORKTOP  
    Address("resource_sim1n2q4le7dpzucmpnksxj5ku28r3t776pgk879cahgm76c2kfpz48fpj")  
    Bucket("nfts")  
;
CREATE_PROOF_FROM_BUCKET_OF_ALL  
    Bucket("nfts")  
    Proof("proof")  
;
```

--------------------------------

### Create an AccessRule Requiring a Specific Resource

Source: https://docs.radixdlt.com/docs/auth

This example demonstrates how to create a basic AccessRule that requires a proof of a specific resource address to be present in the AuthZone for access.

```scrypto
let some_resource_address: ResourceAddress = { .. }; 
let access_rule: AccessRule = rule!(require(some_resource_address));  
```

--------------------------------

### Radix Node Configuration File Example

Source: https://docs.radixdlt.com/docs/node-setup-systemd

Create a configuration file for your Radix node. This example shows settings for network ID and seed nodes, which should be chosen based on the network you are joining (Mainnet or Stokenet).

```properties
# The ID of the network to connect to (Mainnet=1, Stokenet=2), see above  
network.id=1|2  
# A comma-separated list of network seed nodes, copy-paste from above (must match network.id)  
network.p2p.seed_nodes=<see-above>  
  
node.key.path=/srv/radixdlt/babylon-mainnet/keystore.ks  
db.location=/srv/radixdlt/babylon-mainnet/data  
```

--------------------------------

### Install CMake and LLVM on macOS

Source: https://docs.radixdlt.com/docs/getting-rust-scrypto

Installs CMake and LLVM using Homebrew. Ensure Homebrew is installed first.

```bash
brew install cmake llvm  
```

--------------------------------

### Create and Deposit Bucket in Kotlin

Source: https://docs.radixdlt.com/docs/radix-engine-toolkit-manifest-builder

Illustrates creating a bucket named 'xrdBucket' by taking XRD from the worktop and then depositing it into an account using the manifest builder. This example highlights the 'takeFromWorktop' source method and the 'accountTryDepositOrAbort' sink method.

```Kotlin
import com.radixdlt.ret.*

fun main(args: Array<String>) {
    val networkId: UByte = 0x02u
    val xrd = knownAddresses(networkId).resourceAddresses.xrd  

    val address = Address("account_tdx_2_169ukwfsne0zvwrvsyk3mm3x7m6hggup52t6ng547m9a2qp6q5y99h8")  

    val manifest =  
        ManifestBuilder()  
            .faucetFreeXrd()  
            // The following is a source method that creates a bucket by taking a specified amount  
            // of resources from the worktop and into a bucket. The name to use for this bucket is  
            // `xrdBucket`. Any following method that wishes to refer to this bucket, it must refer  
            // to it using the name given to it here.  
            .takeFromWorktop(xrd, Decimal("10000"), ManifestBuilderBucket("xrdBucket"))  
            // The following is a sink method that consumes buckets by depositing them into an  
            // account. When wishing to refer to the bucket created by the previous method the same  
            // name that the bucket was created with is used again here.  
            .accountTryDepositOrAbort(address, ManifestBuilderBucket("xrdBucket"), null)  
            .build(networkId)
}
```

--------------------------------

### PreciseDecimal Example

Source: https://docs.radixdlt.com/docs/manifest-value-syntax

Example of a PreciseDecimal manifest value.

```typescript
PreciseDecimal("1231232342342.123213123123")
```

--------------------------------

### Decimal Example

Source: https://docs.radixdlt.com/docs/manifest-value-syntax

Example of a Decimal manifest value.

```typescript
Decimal("-123.456")
```

--------------------------------

### Instantiate a Component

Source: https://docs.radixdlt.com/docs/learning-to-run-your-first-scrypto-project

Use this command to create a new instance of a component from a deployed Scrypto package in the simulator. Replace `<PACKAGE_ADDRESS>` with the actual address of your deployed package.

```bash
resim call-function <PACKAGE_ADDRESS> Hello instantiate_hello  
```

--------------------------------

### AddressReservation Example

Source: https://docs.radixdlt.com/docs/manifest-value-syntax

Example of an AddressReservation manifest value.

```typescript
AddressReservation("address_reservation")
```

--------------------------------

### Instantiate and Globalize Hello Component

Source: https://docs.radixdlt.com/docs/learning-to-explain-your-first-scrypto-project

Instantiates a 'Hello' component and prepares it for global access on the network. This is typically the final step in setting up a component.

```rust
Self {
        sample_vault: Vault::with_bucket(my_bucket),
    }
    // 6. Instantiate the component
    .instantiate()
    // 7. Make the component available in the network
    .prepare_to_globalize(OwnerRole::None)
    .globalize()

```

--------------------------------

### Install Supported LLVM Version

Source: https://docs.radixdlt.com/docs/coverage-tool

Installs LLVM version 18, which is required for Rust 1.81.0-nightly. This involves adding the LLVM repository and then installing the specific version.

```bash
apt install lsb-release wget software-properties-common gnupg  
bash -c "$(wget -O - https://apt.llvm.org/llvm.sh 18)"  
apt install llvm-18  

```

--------------------------------

### Named Proof Example

Source: https://docs.radixdlt.com/docs/manifest-value-syntax

Example of a named proof in the manifest.

```typescript
Proof("auth")
```

--------------------------------

### Verify Radix Engine Toolkit Installation (C#)

Source: https://docs.radixdlt.com/docs/radix-engine-toolkit-installation

Use the `BuildInformation()` method to print build details of the Radix Engine Toolkit Core. Ensure the `RadixEngineToolkit` namespace is imported.

```csharp
using RadixEngineToolkit;

Console.WriteLine(RadixEngineToolkitUniffiMethods.BuildInformation());

```

--------------------------------

### Component Instantiation Output

Source: https://docs.radixdlt.com/docs/learning-to-run-your-first-scrypto-project

This is an example of the output you can expect after successfully instantiating a component. It details transaction status, costs, emitted events, balance changes, and newly created entities like components and resources.

```text
Transaction Status: COMMITTED SUCCESS  
Transaction Cost: 0.65177966419 XRD  
├─ Network execution: 0.30327475 XRD, 6065495 execution cost units  
├─ Network finalization: 0.1260127 XRD, 2520254 finalization cost units  
├─ Tip: 0 XRD  
├─ Network Storage: 0.22249221419 XRD  
└─ Royalties: 0 XRD  
Logs: 0  
Events: 7  
├─ Emitter: Method { node: internal_vault_sim1tz9uaalv8g3ahmwep2trlyj2m3zn7rstm9pwessa3k56me2fcduq2u, module_id: Main }  
   Event: LockFeeEvent {  
     amount: Decimal("5000"),  
   }  
├─ Emitter: Method { node: resource_sim1t4h3kupr5l95w6ufpuysl0afun0gfzzw7ltmk7y68ks5ekqh4cpx9w, module_id: Main }  
   Event: MintFungibleResourceEvent {  
     amount: Decimal("1000"),  
   }  
├─ Emitter: Method { node: resource_sim1t4h3kupr5l95w6ufpuysl0afun0gfzzw7ltmk7y68ks5ekqh4cpx9w, module_id: Main }  
   Event: VaultCreationEvent {  
     vault_id: NodeId(hex("5855080b052e56996aeedf0045f0ab8b2d6081e2bec248684ba4b5c2b03e")),  
   }  
├─ Emitter: Method { node: internal_vault_sim1tp2sszc99etfj6hwmuqytu9t3vkkpq0zhmpys6zt5j6u9vp7u6438n, module_id: Main }  
   Event: DepositEvent {  
     amount: Decimal("1000"),  
   }  
├─ Emitter: Method { node: internal_vault_sim1tz9uaalv8g3ahmwep2trlyj2m3zn7rstm9pwessa3k56me2fcduq2u, module_id: Main }  
   Event: PayFeeEvent {  
     amount: Decimal("0.65177966419"),  
   }  
├─ Emitter: Method { node: internal_vault_sim1tpsesv77qvw782kknjks9g3x2msg8cc8ldshk28pkf6m6lkhun3sel, module_id: Main }  
   Event: DepositEvent {  
     amount: Decimal("0.325889832095"),  
   }  
└─ Emitter: Method { node: resource_sim1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxakj8n3, module_id: Main }  
   Event: BurnFungibleResourceEvent {  
     amount: Decimal("0.325889832095"),  
   }  
Outputs: 3  
├─ Unit  
├─ Reference("component_sim1crkp7q8sfhg7xa0xvqtdjezltj3hams2hrk4ztzqs2c90sy0cslv6a")  
└─ Enum::[0]  
Balance Changes: 3  
├─ Vault: internal_vault_sim1tz9uaalv8g3ahmwep2trlyj2m3zn7rstm9pwessa3k56me2fcduq2u  
   ResAddr: resource_sim1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxakj8n3  
   Change: -0.65177966419  
├─ Vault: internal_vault_sim1tp2sszc99etfj6hwmuqytu9t3vkkpq0zhmpys6zt5j6u9vp7u6438n  
   ResAddr: resource_sim1t4h3kupr5l95w6ufpuysl0afun0gfzzw7ltmk7y68ks5ekqh4cpx9w  
   Change: 1000  
└─ Vault: internal_vault_sim1tpsesv77qvw782kknjks9g3x2msg8cc8ldshk28pkf6m6lkhun3sel  
   ResAddr: resource_sim1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxakj8n3  
   Change: 0.325889832095  
New Entities: 2  
└─ Component: component_sim1crkp7q8sfhg7xa0xvqtdjezltj3hams2hrk4ztzqs2c90sy0cslv6a  
└─ Resource: resource_sim1t4h3kupr5l95w6ufpuysl0afun0gfzzw7ltmk7y68ks5ekqh4cpx9w  

```

--------------------------------

### Named Bucket Example

Source: https://docs.radixdlt.com/docs/manifest-value-syntax

Example of a named bucket in the manifest.

```typescript
Bucket("my_awesome_xrd_bucket")
```

--------------------------------

### Install Radix CLIs on Windows

Source: https://docs.radixdlt.com/docs/getting-rust-scrypto

Installs the Radix Engine Simulator and command-line tools using Cargo. The --force flag ensures the latest version is installed.

```bash
cargo install --force radix-clis@1.3.0  
```

--------------------------------

### Create a New Scrypto Package

Source: https://docs.radixdlt.com/docs/coverage-tool

Creates a new Scrypto package named 'hello' for testing purposes. This command initializes the basic structure for a blueprint.

```bash
scrypto new-package hello  

```

--------------------------------

### Unnamed Proof Example

Source: https://docs.radixdlt.com/docs/manifest-value-syntax

Example of an unnamed proof, specified by its index.

```typescript
Proof(100u32)
```

--------------------------------

### Unnamed Bucket Example

Source: https://docs.radixdlt.com/docs/manifest-value-syntax

Example of an unnamed bucket, specified by its index.

```typescript
Bucket(5u32)
```

--------------------------------

### Test Hello Blueprint with Simulated Ledger

Source: https://docs.radixdlt.com/docs/scrypto-test

This snippet demonstrates how to test the 'Hello' blueprint using the LedgerSimulator. It covers environment setup, account creation, package compilation and publishing, instantiating the component, and calling its methods.

```rust
use scrypto_test::prelude::*;

#[test]
fn test_hello() {
    // Setup the environment
    let mut ledger = LedgerSimulatorBuilder::new().build();

    // Create an account
    let (public_key, _private_key, account) = ledger.new_allocated_account();

    // Publish package
    let package_address = ledger.compile_and_publish(this_package!());

    // Test the `instantiate_hello` function.
    let manifest = ManifestBuilder::new()
        .lock_fee_from_faucet()
        .call_function(
            package_address,
            "Hello",
            "instantiate_hello",
            manifest_args!(),
        )
        .build();
    let receipt = ledger.execute_manifest(
        manifest,
        vec![NonFungibleGlobalId::from_public_key(&public_key)],
    );
    println!("{:?}\n", receipt);
    let component = receipt.expect_commit(true).new_component_addresses()[0];

    // Test the `free_token` method.
    let manifest = ManifestBuilder::new()
        .lock_fee_from_faucet()
        .call_method(component, "free_token", manifest_args!()) 
        .call_method(
            account,
            "deposit_batch",
            manifest_args!(ManifestExpression::EntireWorktop),
        )
        .build();
    let receipt = ledger.execute_manifest(
        manifest,
        vec![NonFungibleGlobalId::from_public_key(&public_key)],
    );
    println!("{:?}\n", receipt);
    receipt.expect_commit_success();
}

```

--------------------------------

### Install Full Node Nginx Configuration

Source: https://docs.radixdlt.com/docs/node-setup-systemd-update

Copies the specific Nginx configuration file for a full node.

```bash
sudo cp nginx-fullnode.conf /etc/nginx/nginx.conf
```

--------------------------------

### Named Address Example

Source: https://docs.radixdlt.com/docs/manifest-value-syntax

Example of using a NamedAddress, typically from an AddressReservation.

```typescript
NamedAddress("my_package")
```

--------------------------------

### Create Proof from Bucket of Amount

Source: https://docs.radixdlt.com/docs/manifest-instructions

Creates a proof of a specific amount of a resource from a bucket. Requires taking all from worktop first.

```radix-instruction
TAKE_ALL_FROM_WORKTOP  
    Address("resource_sim1tknxxxxxxxxxradxrdxxxxxxxxx009923554798xxxxxxxxxakj8n3")  
    Bucket("xrd_bucket")  
;
CREATE_PROOF_FROM_BUCKET_OF_AMOUNT  
    Bucket("xrd_bucket")  
    Decimal("1.0")  
    Proof("proof")  
;
```

--------------------------------

### Fixed Address Examples

Source: https://docs.radixdlt.com/docs/manifest-value-syntax

Examples of how to represent fixed addresses in the manifest.

```typescript
Address("package_address")
Address("component_address")
Address("resource_address")
```

--------------------------------

### Install Rust Compiler and Target

Source: https://docs.radixdlt.com/docs/coverage-tool

Installs the Rust compiler using the official installation script and sets the default environment. It also adds the `wasm32-unknown-unknown` target for WebAssembly compilation.

```bash
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh  
source $HOME/.cargo/env  
rustup target add wasm32-unknown-unknown  

```

--------------------------------

### Enum Alias Examples

Source: https://docs.radixdlt.com/docs/manifest-value-syntax

Examples of Some, None, Ok, and Err enum variants.

```typescript
Some("Hello World")
```

```typescript
None
```

```typescript
Ok("Success message.")
```

```typescript
Err("Failure message.")
```

--------------------------------

### Unit Alias Example

Source: https://docs.radixdlt.com/docs/manifest-value-syntax

Example of the Unit alias, representing an empty tuple.

```typescript
()
```

--------------------------------

### Enable Radix Node Systemd Service Autostart

Source: https://docs.radixdlt.com/docs/node-setup-systemd

Configure the Radix node service to automatically start on system boot using systemctl enable.

```bash
sudo systemctl enable babylon-node.service
```

--------------------------------

### Blob Example

Source: https://docs.radixdlt.com/docs/manifest-value-syntax

Example of a Blob manifest value, referencing content by hash.

```typescript
Blob("<black2b_hash_of_the_blob_contents>")
```

--------------------------------

### NonFungibleGlobalId Metadata Example

Source: https://docs.radixdlt.com/docs/entity-metadata

Example of using a NonFungibleGlobalId in metadata, with a fixed field.

```rust
.metadata(metadata! {
    init {
        "badge" => NonFungibleGlobalId::new(
            resource_address,
            NonFungibleLocalId::integer(1),
        ), fixed;
    }
})

```

--------------------------------

### Configure and Instantiate Radix Dapp Toolkit

Source: https://docs.radixdlt.com/docs/learning-to-run-your-first-front-end-dapp

Sets up the configuration for the Radix Dapp Toolkit, specifying the network, application details, and dApp definition address. This instance is then used to interact with the wallet and network.

```javascript
// Create a dapp configuration object for the Radix Dapp Toolkit
const dappConfig = {
  networkId: RadixNetwork.Stokenet,
  applicationVersion: "1.0.0",
  applicationName: "Hello Token dApp",
  applicationDappDefinitionAddress: dAppDefinitionAddress,
};
// Instantiate DappToolkit to connect to the Radix wallet and network
const rdt = RadixDappToolkit(dappConfig);

```

--------------------------------

### NonFungibleLocalId Examples

Source: https://docs.radixdlt.com/docs/manifest-value-syntax

Examples of NonFungibleLocalId in various formats: String, Integer, Bytes, and RUID.

```typescript
NonFungibleLocalId("<SomeId>")
```

```typescript
NonFungibleLocalId("#12123#")
```

```typescript
NonFungibleLocalId("[031b84c5567b126440995d3ed5aaba05]")
```

```typescript
NonFungibleLocalId("{43968a7243968a72-5954595459545954-45da967845da9678-8659dd398659dd39}")
```

--------------------------------

### Expression Examples

Source: https://docs.radixdlt.com/docs/manifest-value-syntax

Examples of using the Expression manifest value for worktop and auth zone.

```typescript
Expression("ENTIRE_WORKTOP")
```

```typescript
Expression("ENTIRE_AUTH_ZONE")
```

--------------------------------

### Instant Metadata Example

Source: https://docs.radixdlt.com/docs/entity-metadata

Example of using an Instant datatype in metadata, with an updatable field.

```rust
.metadata(metadata! {
    init {
        "last_updated" => Instant {
            seconds_since_unix_epoch: 1687446137,
        }, updatable;
    }
})

```

--------------------------------

### Create and Use a Bucket with ManifestBuilder

Source: https://docs.radixdlt.com/docs/radix-engine-toolkit-manifest-builder

This snippet shows how to create a bucket named 'xrdBucket' by taking XRD from the worktop and then depositing its contents into an account. Use this to manage resource transfers within a transaction manifest.

```swift
let manifest = try! ManifestBuilder()  
    .faucetFreeXrd()  
    .takeFromWorktop(  
        resourceAddress: xrd,   
        amount: Decimal(value: "10000"),   
        intoBucket: ManifestBuilderBucket(name: "xrdBucket")  
    )  
    .accountTryDepositOrAbort(  
        accountAddress: address,   
        bucket: ManifestBuilderBucket(name: "xrdBucket"),  
        authorizedDepositorBadge: nil  
    )  
    .build(networkId: networkId)
```

--------------------------------

### Decimal Metadata Example

Source: https://docs.radixdlt.com/docs/entity-metadata

Example of using a Decimal datatype in metadata, with a fixed field.

```rust
.metadata(metadata! {
    init {
        "pi" => dec!("3.145"), fixed;
    }
})

```

--------------------------------

### Install jq on Ubuntu

Source: https://docs.radixdlt.com/docs/node-setup-docker

Install the `jq` utility on Ubuntu systems to easily parse JSON data returned by Radix node APIs. This is recommended for simplifying command-line queries.

```bash
sudo apt install jq  

```

--------------------------------

### Arrange Test Conditions

Source: https://docs.radixdlt.com/docs/learning-to-explain-your-first-test

Set up the test environment by compiling and publishing the package, then instantiating the blueprint component.

```rust
# Arrange
    let mut env = TestEnvironment::new();
    let package_address = PackageFactory::compile_and_publish(this_package!(), &mut env)?;

    let mut hello = Hello::instantiate_hello(package_address, &mut env)?;

```

--------------------------------

### I64 Metadata Example

Source: https://docs.radixdlt.com/docs/entity-metadata

Example of using an I64 datatype in metadata, with a fixed field.

```rust
.metadata(metadata! {
    init {
        "some_i64" => 3i64, fixed;
    }
})

```

--------------------------------

### Scrypto CLI Help Output

Source: https://docs.radixdlt.com/docs/scrypto-cli-tool

Displays the available commands and options for the scrypto CLI tool. Use this to understand the basic functionalities.

```bash
scrypto 1.0.0  
Create, build and test Scrypto code  
  
USAGE:  
    scrypto <SUBCOMMAND>  
  
OPTIONS:  
    -h, --help       Print help information  
    -V, --version    Print version information  
  
SUBCOMMANDS:  
    build          Build a Scrypto package  
    fmt            Format a Scrypto package  
    help           Print this message or the help of the given subcommand(s)  
    new-package    Create a Scrypto package  
    test           Run Scrypto tests  

```

--------------------------------

### I32 Metadata Example

Source: https://docs.radixdlt.com/docs/entity-metadata

Example of using an I32 datatype in metadata, with a fixed field.

```rust
.metadata(metadata! {
    init {
        "some_i32" => 3i32, fixed;
    }
})

```
Tokens:
Raw