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.


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:

let a: Decimal = dec!("-10.335");

info!("{}", a.abs()); // displays 10.335
info!("{}", a.floor()); // displays -11
info!("{}", a.ceiling()); // displays -10
info!("{}", a.round(2, RoundingMode::TowardsNearestAndHalfAwayFromZero)); // displays -10.34

let b: Decimal = 4.into();

info!("{}", b.powi(2)); // displays 16

Use PreciseDecimal`if you want to calculate compound interest using the `powi() method as it provides way enough precision to yield to precise results.

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:

pub enum Color {

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.

Type Description


Represents the system-wide address of a Package.


Represents the system-wide address of a Component.


Represents a reference to a global object (e.g Global<MyComponent>).


Represents a local component to be globalized.


Represents an attached module to a global object (e.g Attached<Metadata>).


Represents an owned local component.


Represents a lookup table and the data it contains. It uses key-value pairs to store and retrieve data.

Type Description


Represents a 32-byte hash digest. Currently, the only supported hash algorithm is SHA256.


Represents an ECDSA public key. Currently, the only supported curve is secp256k1.


Represents an ECDSA signature. Currently, the only supported curve is secp256k1.

Type Description


Represents a signed, bounded fixed-point decimal, where the precision is 10^-18.


Represents a 512 bit representation of a fixed-scale decimal number, where precision is 10^-64

Type Description



Represents a bucket of resources. Can be of fungible or non-fungible type. Resources in Scrypto can only be moved using Buckets.


Represents a bucket of fungible resource. This bucket can only contain fungible resource.


Represents a bucket of non-fungible resource. This bucket can only contain non-fungible resource.


Represents a proof of ownership of a resource. Can be a proof of a fungible resource or non-fungible resource.


Represents a proof of a fungible resource. Can only be of a fungible resource.


Represents a proof of a non-fungible resource. Can only be of a non-fungible resource.


Represents a proof that has been validated to be legitimate at the application layer.


Represents a vault of resources. Resources in Scrypto can only be stored using Vaults.


Represents a vault which contain fungible resource. Can only contain fungible resource.


Represents a vault which contain a non-fungible resource. Can only contain non-fungible resource.


Represents a system-wide address of a Non-Fungible Resource.


Represents an Id of an Non-Fungible Resource.