Enums

Sway Enums are a little distinct from TypeScript Enums. In this document, we will explore how you can represent Sway Enums in the SDK and how to use them with Sway contract functions.

Basic Sway Enum Example

Consider the following basic Sway Enum called StateError:

pub enum StateError {
    Void: (),
    Pending: (),
    Completed: (),
}

See code in context

---

The type () indicates that there is no additional data associated with each Enum variant. Sway allows you to create Enums of Enums or associate types with Enum variants.

Using Sway Enums As Function Parameters

Let's define a Sway contract function that takes a StateError Enum variant as an argument and returns it:

fn echo_state_error_enum(state_error: StateError) -> StateError {
    state_error
}

See code in context

---

To execute the contract function and validate the response, we can use the following code:

const enumVariant = 'Completed';

const { value } = await contract.functions.echo_state_error_enum(enumVariant).simulate();

expect(value).toEqual(enumVariant);

See code in context

---

In this example, we simply pass the Enum variant as a value to execute the contract function call.

Enum of Enums Example

In this example, the Error Enum is an Enum of two other Enums: StateError and UserError.

pub enum StateError {
    Void: (),
    Pending: (),
    Completed: (),
}

pub enum UserError {
    Unauthorized: (),
    InsufficientPermissions: (),
}

pub enum Error {
    StateError: StateError,
    UserError: UserError,
}

See code in context

Using Enums of Enums with Contract Functions

Now, let's create a Sway contract function that accepts any variant of the Error Enum as a parameter and returns it immediately. This variant could be from either the StateError or UserError Enums.

fn echo_error_enum(error: Error) -> Error {
    error
}

See code in context

---

Since the Error Enum is an Enum of Enums, we need to pass the function parameter differently. The parameter will be a TypeScript object:

const userErroVar = 'InsufficientPermissions';

const enumParam = { UserError: userErroVar };

const { value } = await contract.functions.echo_error_enum(enumParam).simulate();

expect(value).toEqual(enumParam);

See code in context

---

In this case, since the variant InsufficientPermissions belongs to the UserError Enum, we create a TypeScript object using the Enum name as the object key and the variant as the object value.

We would follow the same approach if we intended to use a variant from the StateError Enum:

const stateErrorVar = 'Completed';

const enumParam = { StateError: stateErrorVar };

const { value } = await contract.functions.echo_error_enum(enumParam).simulate();

expect(value).toEqual(enumParam);

See code in context