Introducción a Blockchain, Tezos y SmartPy

Conceptos básicos de la cadena de bloques

Antes de que podamos comprender completamente a Tezos y SmartPy, primero debemos comprender la tecnología que sustenta todo: la cadena de bloques. Una cadena de bloques es una cadena de bloques, y cada bloque contiene una lista de transacciones. La tecnología Blockchain proporciona una base de datos descentralizada, o "libro mayor digital", de transacciones que todos los participantes de la red pueden ver. Su arquitectura garantiza que cada transacción sea única y, una vez registrada en una base de datos, es imposible cambiarla.

Introducción a Tezos

Tezos es una de esas plataformas blockchain. Lo que distingue a Tezos de muchas otras plataformas blockchain, como Bitcoin o Ethereum, es su énfasis en la "autoenmienda", que permite que el protocolo se actualice por sí solo sin la necesidad de una bifurcación dura. Este es un beneficio significativo ya que hace que el protocolo sea adaptable y esté preparado para el futuro.

Tezos también ofrece una plataforma para contratos inteligentes, que son contratos autoejecutables en los que el acuerdo entre comprador y vendedor está escrito directamente en líneas de código. Esta capacidad de gestionar y verificar acuerdos digitales ofrece una amplia gama de aplicaciones potenciales, desde servicios financieros hasta cadenas de suministro y aplicaciones descentralizadas (DApps). Lea más sobre Tezos: ¿Qué es Tezos? Todo lo que necesitas saber sobre XTZ

SmartPy: lenguaje de contrato inteligente para Tezos

Para crear contratos inteligentes en Tezos, utilizamos un lenguaje llamado SmartPy. SmartPy es una biblioteca de Python para desarrollar contratos inteligentes para la cadena de bloques Tezos. Es un lenguaje intuitivo y eficaz para expresar contratos y sus escenarios de prueba asociados.

La característica más notable de SmartPy es su integración con Python, que es uno de los lenguajes de programación más populares y de más rápido crecimiento del mundo. Si ya está familiarizado con Python, encontrará que SmartPy es bastante fácil de aprender.

Primeros pasos con SmartPy y su primer contrato

Accediendo al IDE de SmartPy

SmartPy incluye un entorno de desarrollo integrado (IDE) con todas las funciones al que se puede acceder desde su navegador web. Vaya al IDE de SmartPy para comenzar a escribir su primer contrato inteligente.

Redactar su primer contrato

En el IDE de SmartPy, encontrará una ventana de edición donde podrá ingresar su código de contrato. Comencemos escribiendo un contrato básico. Copie y pegue el siguiente código en el editor SmartPy:

Python 
 importar smartpy como sp 

 # Un módulo SmartPy 
 @sp.module 
 def main(): 
 # Una clase de contratos 
 clase MyContract(sp.Contract): 
 def __init__(self, myParameter1, myParameter2): 
 self.data.myParameter1 = miParámetro1 
 self.datos.miParámetro2 = myParameter2 

 # Un punto de entrada, es decir, un receptor de mensajes 
 # (los contratos reaccionan a los mensajes) 
 @sp.entrypoint 
 def myEntryPoint(self, params): 
 afirmar self.data.myParameter1 <= 123 
 self.data.myParameter1 += parámetros

Comprender el contrato

Este código de contrato tiene varias partes importantes:

• import smartpy as sp : esto importa la biblioteca SmartPy para que podamos usarla para escribir nuestro contrato.

• @sp.module : este decorador le dice al intérprete de SmartPy que esta función contendrá un contrato de SmartPy.

• class MyContract(sp.Contract): - Aquí definimos una nueva clase (un modelo para crear nuevos objetos) para nuestro contrato. Hereda de la superclase sp.Contract , que proporciona muchas funcionalidades útiles para manejar el estado del contrato y definir su comportamiento.

• self.data.myParameter1 = myParameter1 y self.data.myParameter2 = myParameter2 : aquí estamos definiendo el estado inicial de nuestro contrato. Estos dos parámetros se pasarán al contrato cuando se implemente en la cadena de bloques.

• @sp.entrypoint : este decorador le dice al intérprete que la siguiente función (myEntryPoint) es un punto de entrada de nuestro contrato. Los puntos de entrada son la forma en que interactuamos con nuestro contrato una vez que se ha implementado.

• self.data.myParameter1 += params : esta línea de código incrementa myParameter1 por la cantidad pasada a myEntryPoint.

Probando el contrato

Una parte vital de la redacción de contratos es probarlos minuciosamente. Las pruebas en SmartPy están integradas en el proceso de desarrollo. Así es como puede agregar pruebas al contrato:

Python 
 # Pruebas 
 @sp.add_test(name="Bienvenido") 
 def test(): 
 # Definimos un escenario de prueba, junto con algunas salidas y comprobaciones 
 # El escenario toma el módulo como parámetro 
 escenario = sp .test_scenario(principal)
    escenario.h1("Bienvenido")

    # Primero definimos un contrato y lo agregamos al escenario 
 c1 = main.MyContract(12, 123) 
 escenario += c1 

 # Y llamamos a algunos de sus puntos de entrada 
 c1.myEntryPoint(12) 
 c1.myEntryPoint(13) 
 c1.myEntryPoint(14) 
 c1.myEntryPoint(50) 
 c1.myEntryPoint(50) 
 c1.myEntryPoint(50).run(valid=False)  # Se espera que esto falle 

 # Finalmente, verificamos su almacenamiento final 
 escenario.verify(c1.data.myParameter1 == 151) 

 # Podemos definir otro contrato usando el estado actual de c1 
 c2 = main.MyContract(1, c1.data.myParameter1)
    escenario += c2 
 escenario.verify(c2.data.myParameter2 == 151)

Ejecución del contrato y las pruebas

Su contrato completo ahora debería ser así:

Python 
 importa smartpy como sp 

 # Este es el editor SmartPy.
# Puedes experimentar con SmartPy cargando una plantilla.
# (en el menú Comandos encima de este editor) 
 # 
 # Un programa SmartPy típico tiene la siguiente forma: 


 # Un módulo SmartPy 
 @sp.module 
 def main(): 
 # Una clase de contratos 
 class MyContract(sp .Contrato): 
 def __init__(self, myParameter1, myParameter2): 
 self.data.myParameter1 = miParámetro1 
 self.datos.miParámetro2 = myParameter2 

 # Un punto de entrada, es decir, un receptor de mensajes 
 # (los contratos reaccionan a los mensajes) 
 @sp.entrypoint 
 def myEntryPoint(self, params): 
 afirmar self.data.myParameter1 <= 123 
 self.data.myParameter1 += params 


 # Pruebas 
 @sp.add_test(name="Bienvenido") 
 def test(): 
 # Definimos un escenario de prueba, junto con algunas salidas y comprobaciones 
 # El escenario toma el módulo como parámetro 
 escenario = sp.test_scenario(principal)
    escenario.h1("Bienvenido")

    # Primero definimos un contrato y lo agregamos al escenario 
 c1 = main.MyContract(12, 123) 
 escenario += c1 

 # Y llamamos a algunos de sus puntos de entrada 
 c1.myEntryPoint(12) 
 c1.myEntryPoint(13) 
 c1.myEntryPoint(14) 
 c1.myEntryPoint(50) 
 c1.myEntryPoint(50) 
 c1.myEntryPoint(50).run(valid=False)  # Se espera que esto falle 

 # Finalmente, verificamos su almacenamiento final 
 escenario.verify(c1.data.myParameter1 == 151) 

 # Podemos definir otro contrato usando el estado actual de c1 
 c2 = main.MyContract(1, c1.data.myParameter1)
    escenario += c2 
 escenario.verify(c2.data.myParameter2 == 151)

Una vez que haya escrito su contrato y sus pruebas, puede ejecutarlos directamente en el IDE. Haga clic en el botón "Ejecutar" en la esquina superior derecha del IDE. El IDE compilará su contrato, ejecutará las pruebas y mostrará el resultado junto con una explicación detallada de cada operación y cambio de estado.

En conclusión, esta lección le presentó la cadena de bloques de Tezos y SmartPy, el lenguaje de contrato inteligente para Tezos. También redactó, comprendió y probó su primer contrato SmartPy. Esto es solo el comienzo: hay mucho más que aprender y hacer con SmartPy y Tezos. ¡Esperamos que esté emocionado de continuar este viaje con nosotros en las próximas lecciones!