Tipos Personalizados

Los tipos personalizados son tipos de estructura, unión y enumeración definidos por contratos. Son utilizables en todas partes donde se pueden usar tipos primitivos: como entradas de contrato, salidas de contrato o para almacenamiento.

información

El ejemplo de tipos personalizados demuestra cómo definir tus propios tipos.

información

Los tipos de enumeración de error son otro tipo que los contratos pueden definir y que tienen comportamientos únicos. Consulta Errores para más información.

Estructuras (con Campos Nombrados)

Las estructuras con campos nombrados se almacenan en el ledger como un mapa de pares clave-valor, donde la clave es una cadena de 32 caracteres que representa el nombre del campo, y el valor es el valor codificado.

Los nombres de los campos no deben tener más de 32 caracteres. Los campos con nombres de no más de 9 caracteres son ligeramente más eficientes en tiempo de ejecución, aunque la diferencia debería ser marginal la mayor parte del tiempo.

#[contracttype]
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct State {
    pub count: u32,
    pub last_incr: u32,
}

Cuando se convierte a XDR, el valor se convierte en un ScVal, que contiene un ScMap, que contiene un array de pares clave-valor.

{
  "map": [
    { "key": { "symbol": "count" }, "val": { "u32": 0 } },
    { "key": { "symbol": "last_incr" }, "val": { "u32": 0 } }
  ]
}

Estructuras (con Campos No Nombrados)

Las estructuras con campos no nombrados se almacenan en el ledger como un vector de valores, y son intercambiables con tuplas y vectores. Los elementos se colocan en el vector en el orden en que aparecen en la lista de campos.

#[contracttype]
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct State(pub u32, pub u32);

Cuando se convierte a XDR, el valor se convierte en un ScVal, que contiene un ScVec, que contiene un array de valores.

{ "vec": [{ "u32": 0 }, { "u32": 0 }] }

Enumeración (Variante de Unidad y Tupla)

Las enumeraciones que contienen variantes de unidad y tupla se almacenan en el ledger como un vector de dos elementos, donde el primer elemento es el nombre de la variante de enumeración como una cadena de hasta 32 caracteres de longitud, y el valor es el valor si la variante tiene uno.

Solo se admiten variantes de unidad y variantes de tupla, como A y B a continuación.

#[contracttype]
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum Enum {
    A,
    B(u32),
}

Cuando una variante de unidad, como Enum::A, se convierte a XDR, el valor se convierte en un ScVal, que contiene un ScVec, que contiene un array con un solo valor, el símbolo que contiene el nombre de la variante.

{ "vec": [{ "symbol": "A" }] }

Cuando una variante de tupla, como Enum::B, se convierte a XDR, el valor se convierte en un ScVal, que contiene un ScVec, que contiene un array con dos valores, el símbolo que contiene el nombre de la variante y el valor de la tupla.

{ "vec": [{ "symbol": "B" }, { "u32": 0 }] }

Cuando se implementan variantes de tupla que contienen múltiples valores, los valores se incluirán en el vector.

Enumeración (Variantes Enteras)

Las enumeraciones que contienen valores enteros se almacenan en el ledger como el valor u32.

#[contracttype]
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u32)]
pub enum Enum {
    A = 1,
    B = 2,
}

Cuando se convierte a XDR, el valor se convierte en un ScVal, que contiene un U32.

{ "u32": 1 }