Primitivos

Los primitivos son los tipos de datos básicos que se pueden utilizar en el lenguaje javascript. Estos son: string, number, boolean, null, undefined, symbol y bigint. Cada uno de estos tipos de datos tiene sus propias características y métodos; pero el sdk y sus modulos y paquetes también tienen sus propios métodos y características que se pueden utilizar para manipular estos tipos de datos. Sera comun que encuentre objetos que representan datos del sistema y que encapsulan estos tipos de datos, por ejemplo, el objeto EthereumAddress encapsula un tipo de dato string que representa una dirección de ethereum y tiene métodos para manipular o validar esta dirección.

Objetos de valor

EthereumAddress es un ejemplo de un objeto de valor, estos objetos encapsulan un tipo de dato primitivo y tienen métodos para manipular o validar este tipo de dato. Puedes ver más información sobre objetos de valor en la sección Objetos de valor.

Serializacion y deserializacion de clase con primitivos

Sabiendo esto el sdk tiene un tipo generico para extraer el tipo de dato primitivo de un objeto de valor en una clase. Este tipo es Primitives<T> y se puede utilizar de la siguiente manera.

Supongamos que creamos una clase que tiene una propiedad address que es de tipo EthereumAddress y otra propiedad chainId que es de tipo ChainId:

class MyClass {
    constructor(
        public address: EthereumAddress,
        public chainId: ChainId
    ) {}
}

Ahora queremos extraer en un nuevo tipo de dato los primitivos de la clase MyClass, para esto podemos utilizar el tipo Primitives<T> de la siguiente manera:

type MyClassPrimitives = Primitives<MyClass>;

Esto nos creara un nuevo tipo de dato que es la representación de los primitivos de la clase MyClass:

type MyClassPrimitives = {
    address: string; // address ahora es de tipo string y no de tipo EthereumAddress
    chainId: number; // chainId ahora es de tipo number y no de tipo ChainId
}

Ahora podemos hacer que la clase MyClass pueda construirse a partir de los primitivos y tambien que devuelva sus primitivos de la siguiente manera:

class MyClass {
    constructor(
        public address: EthereumAddress,
        public chainId: ChainId
    ) {}

    static from(primitives: MyClassPrimitives): MyClass {
        return new MyClass(
            new EthereumAddress(primitives.address),
            new ChainId(primitives.chainId)
        );
    }

    toPrimitives(): MyClassPrimitives {
        return {
            address: this.address.value,
            chainId: this.chainId.value
        }
    }
}

const myClass = MyClass.from({ 
    address: '0xa73a3b8ACa335855EeaC2f9Fb505BB0360A1B703', 
    chainId: 80001 
});

Ahora la clase MyClass puede construirse a partir de los primitivos de la clase y también se puede serializar utilizando los primitivos de la clase.

const myClassPrimitives = myClass.toPrimitives();

La construccion de todos los objetos de valor o subclases internas quedan encapsulados y solo los conoce la clase MyClass. Mientras que la clase puede ser serializada y deserializada utilizando los primitivos de la clase.

Propiedades privadas de una clase

Las propiedades privadas de una clase no se pueden extraer de una clase y por lo tanto no se pueden serializar utilizando los primitivos de la clase.

class MyPrivateClass {
    private owner: EthereumAddress;

    constructor(
        public address: EthereumAddress,
        public chainId: ChainId
    ) {}
}

type MyPrivateClassPrimitives = Primitives<MyPrivateClass>;

// MyPrivateClassPrimitives es igual a:
type MyPrivateClassPrimitives = {
    address: string;
    chainId: number;
}

En el ejemplo anterior la propiedad owner es privada y no se puede extraer de la clase MyPrivateClass y por lo tanto no se puede serializar utilizando los primitivos de la clase.

Propiedades de solo lectura de una clase

En el caso de las propiedades de solo lectura de una clase, estas se pueden extraer de la clase y por lo tanto se pueden serializar utilizando los primitivos de la clase pero no podran ser modificadas ya que se crearan como propiedades de solo lectura en los primitivos de la clase.

class MyReadOnlyClass {
    constructor(
        readonly address: EthereumAddress,
        readonly chainId: ChainId
    ) {}
}

type MyReadOnlyClassPrimitives = Primitives<MyReadOnlyClass>;

// MyReadOnlyClassPrimitives es igual a:
type MyReadOnlyClassPrimitives = {
    readonly address: string;
    readonly chainId: number;
}

Primitivos de subclases

Si una clase ademas de tener propiedades con objetos de valor tambien tiene propiedades con clases complejas o jerarquias de clases, el tipo Primitives<T> recorrera tambien estas y extraera los primitivos de estas clases.

class MySubClass {
    constructor(
        public address: EthereumAddress,
        public chainId: ChainId
    ) {}
}

class MyClass {
    constructor(
        readonly owner: Owner,
        public subClass: MySubClass
    ) {}
}

type MyClassPrimitives = Primitives<MyClass>;

// MyClassPrimitives es igual a:
type MyClassPrimitives = {
    readonly owner: string;
    subClass: {
        address: string;
        chainId: number;
    }
}

info

Esperamos que esta sección te haya ayudado a entender como se pueden serializar y deserializar clases utilizando los primitivos de estas y que puedas ver que el sdk esta diseñado para que puedas serializar y deserializar objetos de valor y clases de una manera sencilla.