Data Types

Scrypto is based on Rust which is a statically typed language. All variables are associated with a type, either explicitly specified or inferred by the compiler.

In this section, we describe how different data types are supported.

Primitive Types

Most primitive types are supported. You’re free to use any of the following types:

• i8, i16, i32, i64, i128, isize

• u8, u16, u32, u64, u128, usize

• String

isize and usize are compiled into i32 and u32 respectively.

Safe Types

Safe types are types that are guaranteed to panic, when they overflow as opposed to primitive types.

The following types are supported:

• I8, I16, I32, I64, I128, I256, I384, I512

• U8, U16, U32, U64, U128, U256, U384, U512

• Decimal, PreciseDecimal

Notice that there are types that have up to 512 bits of precision.

// builtin types wrap silently instead of panicking in case of overflow
let a: i32 = i32::MAX;
let b: i32 = i32::MAX + 1; // b is wrapping, no panic

// as opposed safe types panic in case of overflow
let c: I32 = I32::MAX;
let d: I32 = I32::MAX + 1; // d is overflowing, panic

Using safe types ensures that a transaction on RadixDLT will be rejected if any of the used safe types would overflow. This is important to make your code safe.

Decimals

You might have noticed that there are no f32 or f64 listed in the previous section. That is because floating point arithmetic is not deterministic and does not work in distributed ledgers systems. Another technique we can use instead is fixed point arithmetic. We implemented this with the Decimal and PreciseDecimal types.

There are multiple ways to instantiate a Decimal:

let a: Decimal = 10.into();
let b: Decimal = dec!(10);
let c: Decimal = dec!("10.333");
let d: Decimal = Decimal::from(20);
let e: Decimal = Decimal::from("20.123444");

Notice that you have to wrap numbers that have a fractional part in quotes. If you don’t, you will not be able to publish the package since it would contain floating-point numbers.

This Decimal type represents a 192 bit fixed-scale decimal number that can have up to 18 decimal places. If you need even more precision, we provide the 256 bit PreciseDecimal type which allows up to 36 decimal places.

Decimal and PreciseDecimal provide you some useful methods:

You can check out the Decimal Scrypto Crate Rust Docs here to see all of them in detail.

Likewise the PreciseDecimal Scrypto Crate Rust Docs here

Struct and Enums

Rust struct and enum are also supported, as long as the fields are of the supported types.

At this stage, no generics are supported for custom structs and enums.

To use enums in Scrypto, you have to make them derive ScryptoSbor:

#[derive(ScryptoSbor)]
pub enum Color {
    White,
    Blue,
    Black,
    Red,
    Green,
}

Container Types

In addition to basic types, the following container types are also supported:

• Option<T>: optional types

• [T; N]: array types

• (T, U, P, L, E): tuple types

• Vec<T>: dynamic-length vector type

• BTreeSet<T>, BTreeMap<K, V>: B-Tree set and map

• HashSet<T>, HashMap<K, V>: Hash set and map

Scrypto Types

Scrypto also introduces a few domain-specific types to enable asset-oriented programming.

Types related to blueprints and components

Types related to cryptograpy

Types related to Math

Types related to Resources