Aplicaciones construidas en Lisk : proyecto Nash Stablecoin

diciembre 11, 2020 VICTOR HUGO LAZARTE 0 Comments

sizing: border-box; line-height: 30px;">. asset , ownerId

Introducción

Nash es una moneda estable que está diseñada para mantener su estabilidad de precios mediante el uso de un mecanismo algorítmico, sin el requisito de un control central sobre la oferta y la demanda, como es el caso de las monedas estables más famosas como Tether, USDC, etc.

Además de los usuarios comunes que pueden comprar Nash como un criptoactivo de valor estable, los arbitrajistas pueden ganar dinero con las fluctuaciones de precios mientras ayudan a mantener la paridad. Además, existe una reserva descentralizada mediante la cual los inversores pueden bloquear sus criptoactivos y obtener ganancias (por ejemplo, utilizando LSK). En el futuro, utilizaremos esta reserva para hacer que el sistema sea sostenible en condiciones críticas.

Finalmente, actualmente estoy trabajando en este proyecto como parte de mi pasantía en Rastak Media Sepehr.
 

Acerca de Stablecoins

Las fluctuaciones de precios algo volátiles de Bitcoin y otras criptomonedas es una de las mayores barreras de entrada para implementarlas en los mercados financieros principales. Como sin estabilidad de precios, es difícil para los mercados de crédito y deuda utilizar justificadamente una criptomoneda.

Por otro lado, las monedas estables han ganado mucha tracción, ya que ofrecen la seguridad y la estabilidad relativa de precios que otras criptomonedas no pueden igualar. Las soluciones de monedas estables actuales buscan combinar los beneficios de la tecnología blockchain con la estabilidad asociada con ciertas monedas fiduciarias o productos básicos específicos.

Cabe señalar que existen muchas monedas estables en el mercado de blockchain, sin embargo, se pueden clasificar en cuatro tipos generales según el tipo de garantía que utilizan:

  1. Con garantía fiduciaria : el tipo más popular de monedas estables está respaldado directamente por una sola moneda o una canasta de monedas fiduciarias. Un emisor central mantiene una cantidad de dinero en una reserva y emite una cantidad proporcional de tokens. El emisor tiene derecho a utilizar la reserva para aumentar la oferta cuando el precio es demasiado alto y, posteriormente, reducirla cuando el precio se vuelve demasiado bajo. El principal problema con respecto a este tipo de monedas estables es el control central de la reserva, que puede resultar en problemas como baja transparencia o puntos únicos de falla.
  2. Con garantía de productos básicos: este tipo utiliza productos básicos (por ejemplo, oro, petróleo) como garantía. Aunque estas son garantías diferentes, en realidad emplea el mismo mecanismo que la moneda estable con garantía fiduciaria y, por lo tanto, también comparte los mismos problemas.
  3. Cripto-colateralizado: con las monedas estables cripto-colateralizadas, los usuarios deben bloquear su criptomoneda en un contrato, que luego emite el token. Cuando es necesario recuperar su garantía, devuelven las monedas estables en el mismo contrato. El principal problema aquí es que es necesario bloquear una cantidad insostenible de criptoactivos para que este sistema funcione.
  4. Sin garantía: con monedas estables sin garantía, estas no están respaldadas por ninguna garantía. En cambio, su paridad se logra íntegramente mediante algoritmos que gestionan el suministro de los tokens emitidos, y al contratar o expandir el suministro automáticamente en diferentes condiciones, el precio se mantendrá estable. Este es el tipo más reciente de moneda estable que ha atraído una gran atención en el último año tanto del mundo académico como de la industria de la criptografía. Sin embargo, desafortunadamente existen algunas monedas estables actualmente en el mercado que se basan en mecanismos algorítmicos, y la mayoría de ellas aún no se han implementado.

A través de este proyecto, mi objetivo es implementar una de las ideas principales sobre monedas estables algorítmicas y acciones de señoreaje, utilizando el Lisk SDK para que pueda ser probado y simulado. Comencé creando una versión de PoC simple con funcionalidades mínimas, y ahora extenderé y desarrollaré las características necesarias para llevarlo a cabo.

¿Cómo actúa Nash?

En este proyecto tenemos 3 tipos de tokens: Nash, Bond y Share. Estos tokens se describen a continuación, incluida la aclaración del mecanismo de estabilidad de precios implementado.

Nash: el token central del sistema que está vinculado directamente al dólar estadounidense.

Bond: Los usuarios de la versión PoC de esta aplicación pueden alimentar el sistema por un precio deseado y probar la aplicación. Si este precio es menor a $ 1, se crearán e inicializarán nuevos bonos, luego se agregarán al mercado de bonos, por lo tanto, todos los usuarios podrán comprarlos con una reducción del 20%, solo si se intercambian por Nash. Así es como se puede reducir la oferta a precios bajos. Además, cuando el precio de Nash sube por encima de $ 1, algunos bonos se convertirán a Nash automáticamente en una orden FIFO para expandir la oferta total de Nash y, posteriormente, devolver el precio a $ 1. Cada bono es equivalente a 100 Nash y también cada bono es una "cuenta" con un objeto de activo personalizado que consta de propiedades como ownerId, precio, estado (vendido, no vendido, vencido).

Compartir: Con este token, los usuarios son como los accionistas de nuestro sistema. Este token es necesario para mantener el sistema estable en condiciones críticas al tener una reserva descentralizada de Lisk. Por ejemplo, si desea comprar una 'acción', la única forma es transferir algunas LSK con un valor de 10LSK / acción a la reserva. Para casos de uso del mundo real, necesitamos implementar un DAO, por lo tanto, los usuarios de este DAO serán accionistas. En condiciones críticas en las que la expansión o contracción algorítmica no es suficiente, los accionistas pueden votar sobre posibles reacciones para manejar la situación utilizando la reserva.

Cuando el sistema quiere expandir la oferta de Nash a precios altos, como máximo el 80% de los nuevos tokens pueden ser respaldados por bonos. Los tokens restantes se distribuirán a los accionistas. De esta manera es posible alentar a las personas a comprar acciones e invertir en la Reserva.

Tenga en cuenta que en la versión PoC ignoramos la implementación del DAO

Transacciones personalizadas

La lista de transacciones personalizadas implementadas se puede ver a continuación:

  1. Transferencia Nash: esto es similar a la transferencia de saldo como una transacción predeterminada en el SDK, pero en lugar del saldo, se cambia la propiedad nash de las cuentas.
  2. // actualizar la cuenta del destinatario
    const new_recipient_nash = ( ! destinatario . activo . nash ) ? esto . activo . cantidad
    : nuevo BigNum ( destinatario . activo . nash ) . agregar ( este . activo . monto ) . toString ( ) ;
    const updated_recipient = { ... destinatario , activo : { ... destinatario . activo , nash : new_recipient_nash } } ;
    tienda . cuenta . conjunto ( updated_recipient . dirección , updated_recipient ) ;
    // actualizar la cuenta del remitente
    const new_sender_nash = new BigNum ( remitente . activo . nash ) . sub ( este . activo . monto ) . toString ( ) ;
    const updated_sender = { ... remitente , activo : { ... remitente . activo , nash : new_sender_nash } } ;
    tienda . cuenta . conjunto ( updated_sender . dirección , updated_sender ) ;
    ver crudoNashTransfer.js alojado con ❤ por GitHub
  3. Transferencia de bonos: los usuarios pueden transferir la propiedad de los bonos entre ellos. El único requisito es cambiar la propiedad ownerId de la cuenta de bonos correspondiente.
  4. // actualizar la cuenta de Bond
    const updated_bond = { ... enlace , activo : { ... enlace . asset , ownerId : esto . activo . newOwnerId } } ;
    tienda . cuenta . establecer ( enlace_actualizado . dirección , enlace_actualizado ) ;
    ver crudoBondTransfer.js alojado con ❤ por GitHub
  5. Compra de acciones: Con esta transacción los usuarios pueden enviar 10 LSK / acción a la cuenta de reserva, y recibirán una acción equivalente correspondiente al valor de 10LSK. Además, es necesario mantener una lista de accionistas, junto con la cantidad de acciones que poseen. Esta información se mantiene en la cuenta de administrador como campo de titulares.
  6. // actualizar la cuenta del remitente
    const new_sender_balance = new BigNum ( remitente . saldo ) . sub ( cantidad_lisk ) . toString ( ) ;
    const new_sender_share = ( ! remitente . activo . compartir ) ? esto . activo . cantidad
    : nuevo BigNum ( remitente . activo . compartir ) . agregar ( este . activo . monto ) . toString ( ) ;
    const updated_sender = { ... remitente , saldo : new_sender_balance , activo : { ... remitente . activo , compartir : new_sender_share } } ;
    tienda . cuenta . conjunto ( remitente . dirección , remitente_actualizado ) ;
    // actualizar la cuenta del administrador
    const new_manager_balance = nueva bignum ( Gestor . equilibrio ) . añadir ( cantidad_lisk ) . toString ( ) ;
    var new_holders = ( ! Gestor . activos . titulares ) ? { } : Gerente . activo . titulares ;
    new_holders [ remitente . dirección ] = new_sender_share ;
    const new_share_supply = ( ! Manager . asset . shareSupply ) ? esto . activo . cantidad
    : nuevo BigNum ( Manager . asset . shareSupply ) . agregar ( este . activo . monto ) . toString ( ) ;
    const updated_manager = { ... Gerente , balance : new_manager_balance ,
    activo : { ... Gerente . activo , titulares : new_holders , shareSupply : new_share_supply } } ;
    tienda . cuenta . conjunto ( updated_manager . dirección , updated_manager ) ;
    ver crudoBuyShare.js alojado con ❤ por GitHub
  7. Sell ​​Share: Esto se basa en la misma lógica que se cubrió en la transacción anterior, solo que esta vez los usuarios venden su parte a la reserva y reciben su LSK de vuelta.
  8. // actualizar la cuenta del remitente
    const new_sender_balance = new BigNum ( remitente . saldo ) . añadir ( cantidad_lisk ) . toString ( ) ;
    const new_sender_share = ( ! remitente . activo . compartir ) ? esto . activo . cantidad :
    nuevo BigNum ( remitente . activo . compartir ) . sub ( este . activo . monto ) . toString ( ) ;
    const updated_sender = { ... remitente , saldo : new_sender_balance ,
    activo : { ... remitente . activo , compartir : new_sender_share } } ;
    tienda . cuenta . conjunto ( updated_sender . dirección , updated_sender ) ;
    // actualizar la cuenta del administrador
    const new_recipient_balance = new BigNum ( destinatario . saldo ) . sub ( cantidad_lisk ) . toString ( ) ;
    var new_holders = destinatario . activo . titulares ;
    new_holders [ remitente . dirección ] = new_sender_share ;
    if ( new_sender_share === '0' ) {
    eliminar new_holders [ remitente . dirección ] ;
    }
    const new_share_supply = new BigNum ( destinatario . activo . shareSupply ) . sub ( este . activo . monto ) . toString ( ) ;
    const updated_recipient = { ... destinatario , saldo : new_recipient_balance ,
    activo : { ... destinatario . activo , titulares : new_holders , shareSupply : new_share_supply } } ;
    tienda . cuenta . conjunto ( updated_recipient . dirección , updated_recipient ) ;
    ver crudoSellShare.js alojado con ❤ por GitHub
  9. Bond2Nash: esta transacción en particular se utiliza en el mecanismo de expansión mediante el cual una cantidad de bonos deben convertirse a Nash. Para implementar esto, se borra el campo ownerId de la cuenta de bonos correspondiente, se cambia el estado a "caducado" y se agregan 100 Nash al saldo de Nash del propietario. Finalmente, la dirección del bono se elimina de la lista de bonos que se encuentra en la cuenta del administrador. Además, el campo nashSupply del administrador también debe actualizarse.
  10. // actualizar la cuenta de Bond
    const updated_bond = { ... enlace , activo : { ... enlace :
'' , status : 'expired' } } ; tienda . cuenta . establecer ( enlace_actualizado . dirección , enlace_actualizado ) ; // actualizar la cuenta del propietarioconst new_owner_nash = ( ! propietario . activo . nash ) ? '100' : nuevo BigNum ( propietario . Activo . Nash ) . agregar ( '100' ) . toString ( ) ; const updated_owner = { ... propietario , activo : { ... propietario . activo , nash : new_owner_nash } } ; tienda . cuenta . conjunto ( updated_owner . dirección , updated_owner ) ; // actualizar la cuenta del administradorconst new_supply = ( ! Manager . asset . nashSupply ) ? '100' : nuevo BigNum ( Manager . Asset . NashSupply ) . agregar ( '100' ) . toString ( ) ; const new_bondsList = Administrador . activo . bondList . filtro ( elemento => elemento ==! bonos . dirección ) ; const updated_Manager = { ... Administrador , activo : { ... Administrador . asset , bondList : new_bondsList , nashSupply : new_supply } } ; tienda . cuenta . conjunto ( updated_Manager . dirección , updated_Manager ) ;
ver crudoBon2Nash.js alojado con ❤ por GitHub
  • Inicialización: Esta transacción se despliega en dos casos, en primer lugar donde es necesario inicializar nuevos enlaces que se crean en un mecanismo de contrato. En este momento, su precio se establece en un valor de 20% menos que (precio actual de nash * 100), el campo de estado se establece en "sin vender", y el propietario se establece en la cuenta del administrador, y luego estarán disponibles en el mercado de bonos. En segundo lugar, el otro caso de uso de esta transacción es inicializar la cuenta del administrador al iniciar la aplicación.
  • si ( este . activo . Tipo === 'administrador' ) {
    const Manager = tienda . cuenta . obtener ( gerente . dirección ) ;
    const updated_Manager = { ... Administrador ,
    activo : { ... Gerente . activo , tipo : 'administrador' , nash : '10000' , nashSupply : '10000' } } ;
    tienda . cuenta . conjunto ( updated_Manager . dirección , updated_Manager ) ;
    }
    otra cosa si ( este . activo . Tipo === 'vínculo' ) {
    if ( ! this . asset . price ) {
    errores . push ( new TransactionError (
    'activo de transacción no válido' ,
    esto . id ,
    '.asset' ,
    esto . activo ,
    'se debe indicar el precio' ) ) ;
    }
    else {
    const bond = tienda . cuenta . obtener ( este . senderId ) ;
    const updated_bond = { ... enlace , activo : { precio : este . activo . precio ,
    status : 'no vendido' , tipo : 'bond' , ownerId : manager . dirección } } ;
    tienda . cuenta . establecer ( enlace_actualizado . dirección , enlace_actualizado ) ;
    }
    }
    ver crudoInitialization.js alojado con ❤ por GitHub
  • Comprar bonos: aquí los usuarios pueden comprar bonos "no vendidos" en el mercado. A través de esta transacción, se deben actualizar las propiedades de propietario y estado de la cuenta de bonos, el saldo de nash del comprador y el suministro de nash del gerente. Además, la dirección del bono se coloca en la lista de bonos vendidos.
  • // actualizar la cuenta del remitente
    const new_sender_nash = new BigNum ( remitente . activo . nash ) . sub ( enlace . activo . precio ) . toString ( ) ;
    const updated_sender = { ... remitente , activo : { ... remitente . activo , nash : new_sender_nash } } ;
    tienda . cuenta . conjunto ( updated_sender . dirección , updated_sender ) ;
    // actualizar la cuenta de Bond
    const updated_bond = { ... enlace , activo : { ... enlace . asset , ownerId : remitente . dirección , estado : 'vendido' } } ;
    tienda . cuenta . establecer ( enlace_actualizado . dirección , enlace_actualizado ) ;
    // actualizar la cuenta del administrador
    const new_supply = new BigNum ( Administrador . activo . nashSupply ) . sub ( enlace . activo . precio ) . toString ( ) ;
    var new_bondsList = ( ! Manager . asset . bondList ) ? [ ] : Gerente . activo . bondList ;
    new_bondsList . empujar ( enlace . dirección ) ;
    const updated_Manager = { ... Administrador , activo : { ... Administrador . asset , bondList : new_bondsList , nashSupply : new_supply } } ;
    tienda . cuenta . conjunto ( updated_Manager . dirección , updated_Manager ) ;
    ver crudoBuyBond.js alojado con ❤ por GitHub
  • Nuevo Nash: durante la expansión de la oferta, algunos de los nuevos Nash deberían distribuirse entre los accionistas. Esto se gestiona a través de las transacciones de NewNash que actualiza el saldo de Nash de los accionistas y también la propiedad nashSupply del administrador.  
  • // actualizar la cuenta del destinatario
    const new_recipient_nash = ( ! destinatario . activo . nash ) ? esto . activo . cantidad
    : nuevo BigNum ( destinatario . activo . nash ) . agregar ( este . activo . monto ) . toString ( ) ;
    const updated_recipient = { ... destinatario , activo : { ... destinatario . activo , nash : new_recipient_nash } } ;
    tienda . cuenta . conjunto ( updated_recipient . dirección , updated_recipient ) ;
    // actualizar la cuenta del administrador
    const new_supply = ( ! Manager . asset . nashSupply ) ? esto . activo . cantidad
    : nuevo BigNum ( Administrador . activo . nashSupply ) . agregar ( este . activo . monto ) . toString ( ) ;
    const updated_Manager = { ... Administrador , activo : { ... Administrador . activo , nashSupply : new_supply } } ;
    tienda . cuenta . conjunto ( updated_Manager . dirección , updated_Manager ) ;
    ver crudoNewNash.js alojado con ❤ por GitHub

    Interfaz

    Como soy un principiante que trabaja con JavaScript, y especialmente en el desarrollo de front-end, me llevará algo de tiempo crear una interfaz de usuario adecuada. Comencé con un front-end muy simple para probar las funcionalidades básicas, y continuaré trabajando y mejorando aún más a versiones superiores lo antes posible. Para complementar aún más mi trabajo, he incluido algunas de las capturas de pantalla relevantes a continuación:






    Conclusión

    Fue una gran experiencia construir este PoC, y continuaré trabajando para mejorar la aplicación aún más, tanto en las transacciones personalizadas como en la interfaz del cliente; y finalmente ampliar las prestaciones y funcionalidades en la plenitud del tiempo. Espero que este blog te haya dado una idea de cómo podemos construir nuestras ideas DeFi con Lisk.

    Si tiene alguna pregunta o comentario, no dude en comunicarse con Discord (usuario `Kasra99ab # 0990`).
     

    Recursos 

    Si se siente inspirado y desea crear su propia aplicación de cadena de bloques de prueba de concepto, consulte el programa Lisk Builders. Puede encontrar más información sobre el programa y el procedimiento de solicitud en la página web de Lisk para el  programa Lisk Builders .


    Fuente: blog de Lisk


        





    sizing: border-box; line-height: 30px;">. asset , ownerId Introducción Nash es una moneda estable que está diseñada para mantener s...