RSK Name Service (RNS) proporciona una arquitectura que permite la identificación de direcciones RSK mediante nombres legibles por personas. El objetivo de esta intro es a hacer un overview de los conceptos básicos para entender que es RNS y como se usa.

Emepezaremos con una breve introducción a RSK y al RIF Token (for dummies). Luego veremos que RNS usa el RIF token como forma de pago. Por último veremos algunos temas más técnicos, orientados al desarrollo e integración de RNS.

Contenidos

RSK y RIF (for dummies)

Esta sección esta dedicada a todos, tanto devs como no devs. Repasamos algunos conceptos básicos sobre la blockchain de RSK, tokens y vemos como se usa y para que sirve RNS.

Qué es RIF?

Para entender qué es RIF hacemos un breve repaso de algunos conceptos.

Smart Contract: lógica definida de forma inmutable sobre la blockchain de RSK.

Token Contract: tipo de Smart Contract que define la lógica para la transacción de valor, en este caso tokens.

RIF OS es un conjunto de protocolos de infraestructura que permiten un desarrollo más rápido, fácil y escalable de aplicaciones distribuidas (DApps) dentro de un entorno unificado.1

Qué significa implementar un protocolo RIF?

El RIF Token está destinado a permitir que cualquier poseedor de tokens consuma cualquier servicio que sea compatible con los protocolos RIF OS. Dichos servicios pueden incluir servicios de infraestructura desarrollados por terceros y cualquier otra aplicación que pueda implementarse en el protocolo que se comprometa a aceptar RIF Tokens como medio para acceder/consumir el servicio o la aplicación.2

Fuel, RBTCs, tokens y otros conceptos que marean

Para usar la lógica definida por un Smart Contract en RSK debemos pagar un fee. Este fee tambien es conocido como fuel o gas. El fuel en RSK se paga con RBTCs (RSK Bitcoins). Entonces, para ejecutar la lógica del RIF Token debemos realizar una transacción y para eso necesitamos RBTCs.

Recordemos que un token esta definido por la lógica de un Smart Contract que vive dentro de la blockchain de RSK. Para transferir RIFs debemos usar nuestros RBTCs para pagar el fuel consumido por la transeferencia.

Qué es RNS?

RSK Name Service (RNS) proporciona una arquitectura que permite la identificación de direcciones RSK mediante nombres legibles por personas.

Una address se ve así: 0x5aaEB6053f3e94c9b9a09f33669435E7ef1bEAeD.

Esa misma address, usando RNS, la podemos representar así: ilanolkies.rsk

Dominios, subdominios, TLDs y otros términos

Cómo funciona nuestro browser? Uno ingresa una pagina web como por ejemplo rsk.co y el navegador encuentra la dirección IP donde esta hosteado ese sitio, y lo muestra en pantalla.

RNS es muy similar. Uno ingresa un alias como ilanolkies.rsk a la interfaz que exponde RNS y puede obtener la address asociada.

Un top level domain (TLD) es el último sufijo del alias, en este caso es rsk. Para obtener un dominio bajo este TLD (ilan.rsk) debemos ganar una subasta. Una vez que ganamos el dominio tenemos el poder sobre el mismo y todos sus subdominios, esto significa que somos dueños de wallet.ilan.rsk o donate.ilan.rsk.

Zoom in a la arquitectura

La arquitectura de RNS esta definida por 3 Smart Contracts:

  • Registrar en español es registrador. Este contrato define la lógica de la subasta, es decir, cómo se apuesta, cómo se paga, quién gana y qué sucede cuando gana. Además define un pago de una renta anual por un cada dominio adquirido.
  • Registry en español es registro. Aquí se registran todos los TLDs, todos los dominios (en particular los .rsk que fueron adquiridos mediante la subasta), y todos los subdominios.
  • Resolver en español es “resolvedor”. Cada dominio registado en el Registry tiene asociado un Resolver que indica que contenido esta asociado a un dominio. RNS implementa un Resolver publico que permite almacenar una address y un contenido asociado al dominio que lo implemente.

architecture

Aplicaciones simples sobre RNS

El ejemplo más común de uso de RNS es el de una wallet. En vez de escribir ‘0xa87b9c8s…’ en el destinatario de una transacción simplemente escribimos ilanolkies.rsk y evitamos cualquier error de tipeo! Podemos probar esto en MyCrypto.

En un exchange podríamos proveer de subdominios a los usuarios, sobre los cuales podemos resolver su dirección de withdrawal, es decir, donde recibirá sus fondos. Por ejemplo ilanolkies.huobi.rsk resolvería mi dirección de withdrawal para mis RIFs o mis BTCs.

RNS for devs

Esta sección es un poco más técnica y va dedicada a quienes ya saben sobre Smart Contracts. La idea principal es presentar como esta desarrollado RNS, que interfaces provee, y como están desarrollados los distintos productos que ofrece.

Registrar, Registry, Resolver… qué es cada uno?

La arquitectura de RNS esta deifnida por 3 contratos:

Registrar

Es el contrato que maneja la lógica de emisión de dominios debajo del TLD rsk. La propiedad del dominio está determinada por una subasta en la que los licitadores envían las ofertas sin saber el monto de la oferta de cualquier otro participante. El mejor postor es el ganador y el precio pagado es la segunda oferta más alta.

Este contracto implementa el protocolo de RIF, por lo que para realizar una apuesta debemos ‘bloquear’ los tokens, y una vez revelado el resultado los usaremos para pagar por el dominio (o si perdemos serán devueltos).

Una vez que ganamos la subasta. El Registrar, dueño del TLD rsk almacena en el Registry el dominio adquirido como un subdominio suyo.

Leer más: Core & Docs

Registry

Este contrato almacena los dominios registrados accecibles mediante un algorítmo que define un arbol en el que cada nodo hereda de su padre. Cada domino tiene un Resolver y un owner asocido. Provee una interfaz para transferir el ownership de un dominio, registrar subdominios debajo del dominio y cambiar el Resolver.

Leer más: Core & Docs

Resolver

RNS provee un public resolver que permite asociad un nodo del Registry con una address y un content (bytes32). Esta resolución es fácil de implementar en cualquier aplicación blockchain tanto off-chain como on-chain.

Leer más: Core & Docs

El arbol de dominios

Observemos como se define el ownership de un nodo en el Registry:

function setSubnodeOwner(bytes32 node, bytes32 label, address ownerAddress) public only_owner(node) {
    bytes32 subnode = keccak256(abi.encodePacked(node, label));
    records[subnode].owner = ownerAddress;
    records[subnode].resolver = records[node].resolver;
}

Vemos entonces que cada nuevo nodo esta almacenado dependiendo de su nodo padre.

registry

Entonces para obtener el hash de un dominio del arbol usamos la función namehash (en Python)3:

def namehash(name):
    if name == '':
        return '\0' * 32
    else:
        label, _, remainder = name.partition('.')
        return sha3(namehash(remainder) + sha3(label))

Cómo implemento un Resolver?

Observemos el Public Resolver.

AbstractRNS rns;
mapping(bytes32=>address) addresses;
mapping(bytes32=>bytes32) hashes;

modifier only_owner(bytes32 node) {
    require(rns.owner(node) == msg.sender);
    _;
}

constructor(AbstractRNS rnsAddr) public {
    rns = rnsAddr;
}

Esta resoución almacena, para cada nodo del Registry, una address y un bytes32 (arreglo de bytes) accesbile de forma pública. Ambos valores son modificables por el owner dentro del Registry, cada setter debe pasar only_owner.

El Public Resolver es una implementación muy sencilla de como resolver un dominio del registry, y sirve como puntapie para el desarrollo de cualqueir otra resolución.

Usando el SDK de JS

El SDK desarrollado por RNS expone una clase que nos permite interactuar con la blockchain de RSK para obtener datos del Public Resolver de forma transparente y fácil de implementar. También permite la interacción con cualqueir otro Resolver que implemente la interfaz del Public Resolver.4

npm install @rnsdomains/rns-sdk-js

var Resolver = require('rns-sdk-js')
resolver = new Resolver(web3.currentProvider, resolverAddress)

Armado de una DApp con MetaMask

El primer ejemplo de DApp presentado por RNS es el RNS Manager. La DApp permite administrar las subastas, el pago de renta por el dominio, el manejo del ownership (como por ejemplo crear subdominios), y manejar la resolución de los dominios y subdominios. Para realizar las transacciones usa MetaMask. Cuando el usuario se loggea en su plugin de MetaMask expone un nodo web3 en el scope de window en el explorer.

Podemos usar este nodo tal y como lo usamos en nuestro entorno de Truffle. Lo único que necesitamos para el desarrollo del Manager es instanciar los contratos y ejecutar los métodos. Al realizar una transacción usando el nodo expuesto, automaticamente se muestra una ventana de confirmación y luego se ejecuta con la cuenta almacenada en MetaMask.

RNS en mi wallet

Como ejemplo podemos tomar la resolución de dominios que hace RNS Manager.5

app.get('/resolvename', function(req, res) {
    let hash = namehash(req.query.name + '.' + config.tld)

    let resolverAddress = registry.resolver(hash)
    if(resolverAddress === '' || resolverAddress === '0x00' || resolverAddress === '0x0000000000000000000000000000000000000000')
        return res.status(200).send(JSON.stringify('0x00'))

    let resolver = resolverInstance.at(resolverAddress)
    if (!resolver.has(hash, 'addr'))
        return res.status(200).send(JSON.stringify('0x00'))

    let result = resolver.addr(hash)

    return res.status(200).send(JSON.stringify(result))
})

Es simple! Instanciamos el Registry y obtenemos el Resolver asociado al namehash del dominio asociado. Si el Resolver implementa la interfaz 'addr' podemos obtener la address asociada.

Fuentes

  1. https://www.rifos.org
  2. https://www.rifos.org/documentation
  3. https://docs.rns.rsk.co/Operation/Resolve-a-name
  4. https://www.npmjs.com/package/@rnsdomains/rns-sdk-js
  5. https://github.com/rnsdomains/RNS-manager