Introdução ao Blockchain, Tezos e SmartPy

Noções básicas de blockchain

Antes de podermos compreender completamente o Tezos e o SmartPy, devemos primeiro compreender a tecnologia que sustenta tudo: o blockchain. Uma blockchain é uma cadeia de blocos, com cada bloco contendo uma lista de transações. A tecnologia Blockchain fornece um banco de dados descentralizado, ou “livro-razão digital”, de transações que todos os participantes da rede podem ver. Sua arquitetura garante que cada transação seja única e, uma vez registrada em um banco de dados, é impossível alterá-la.

Introdução ao Tezos

Tezos é uma dessas plataformas blockchain. O que diferencia o Tezos de muitas outras plataformas blockchain, como Bitcoin ou Ethereum, é sua ênfase na “auto-alteração”, que permite que o protocolo se atualize sem a necessidade de um hard fork. Este é um benefício significativo, pois torna o protocolo adaptável e preparado para o futuro.

A Tezos também oferece uma plataforma para contratos inteligentes, que são contratos autoexecutáveis com o acordo entre comprador e vendedor escrito diretamente em linhas de código. Esta capacidade de gerir e verificar acordos digitais oferece uma ampla gama de aplicações potenciais, desde serviços financeiros a cadeias de abastecimento e aplicações descentralizadas (DApps). Leia mais sobre Tezos: O que é Tezos? Tudo o que você precisa saber sobre o XTZ

SmartPy: linguagem de contrato inteligente para Tezos

Para criar contratos inteligentes no Tezos, usamos uma linguagem chamada SmartPy. SmartPy é uma biblioteca Python para desenvolver contratos inteligentes para o blockchain Tezos. É uma linguagem intuitiva e eficaz para expressar contratos e seus cenários de teste associados.

A característica mais notável do SmartPy é sua integração com Python, que é uma das linguagens de programação mais populares e de crescimento mais rápido do mundo. Se você já está familiarizado com Python, achará o SmartPy muito fácil de aprender.

Primeiros passos com SmartPy e seu primeiro contrato

Acessando o IDE SmartPy

SmartPy inclui um ambiente de desenvolvimento integrado (IDE) completo, acessível a partir de seu navegador. Acesse o IDE SmartPy para começar a escrever seu primeiro contrato inteligente.

Escrevendo seu primeiro contrato

No SmartPy IDE, você encontrará uma janela de edição onde poderá inserir o código do seu contrato. Vamos começar escrevendo um contrato básico. Copie e cole o seguinte código no editor SmartPy:

Python 
 import smartpy as sp 

 # Um módulo SmartPy 
 @sp.module 
 def main(): 
 # Uma classe de contratos 
 class MyContract(sp.Contract): 
 def __init__(self, myParameter1, myParameter2): 
 self.data.myParameter1 = meuParâmetro1 
 self.data.meuParâmetro2 = myParameter2 

 # Um ponto de entrada, ou seja, um receptor de mensagens 
 # (os contratos reagem às mensagens) 
 @sp.entrypoint 
 def myEntryPoint(self, params): 
 assert self.data.myParameter1 <= 123 
 self.data.myParameter1 += parâmetros

Compreendendo o Contrato

Este código de contrato tem várias partes importantes:

• import smartpy as sp - Importa a biblioteca SmartPy para que possamos usá-la para escrever nosso contrato.

• @sp.module - Este decorador informa ao intérprete SmartPy que esta função conterá um contrato SmartPy.

• class MyContract(sp.Contract): - Aqui definimos uma nova classe (um modelo para a criação de novos objetos) para nosso contrato. Ele herda da superclasse sp.Contract , que fornece muitas funcionalidades úteis para lidar com o estado do contrato e definir seu comportamento.

• self.data.myParameter1 = myParameter1 e self.data.myParameter2 = myParameter2 – Aqui estamos definindo o estado inicial do nosso contrato. Esses dois parâmetros serão passados para o contrato quando ele for implantado no blockchain.

• @sp.entrypoint - Este decorador informa ao intérprete que a função a seguir (myEntryPoint) é um ponto de entrada do nosso contrato. Os pontos de entrada são como interagimos com nosso contrato depois de implantado.

• self.data.myParameter1 += params – Esta linha de código aumenta myParameter1 pela quantidade passada para myEntryPoint.

Testando o Contrato

Uma parte vital da redação de contratos é testá-los minuciosamente. Os testes no SmartPy estão integrados ao processo de desenvolvimento. Veja como você pode adicionar testes ao contrato:

Python 
 # Testes 
 @sp.add_test(name="Bem-vindo") 
 def test(): 
 # Definimos um cenário de teste, juntamente com algumas saídas e verificações 
 # O cenário toma o módulo como parâmetro 
 cenário = sp .test_scenario(principal)
    cenário.h1("Bem-vindo")

    # Primeiro definimos um contrato e o adicionamos ao cenário 
 c1 = main.MyContract(12, 123) 
 cenário += c1 

 # E chamamos alguns de seus pontos de entrada 
 c1.myEntryPoint(12) 
 c1.myEntryPoint(13) 
 c1.myEntryPoint(14) 
 c1.myEntryPoint(50) 
 c1.myEntryPoint(50) 
 c1.myEntryPoint(50).run(válido=Falso)  # espera-se que isso falhe 

 # Finalmente, verificamos seu armazenamento final 
 cenário.verify(c1.data.myParameter1 == 151) 

 # Podemos definir outro contrato usando o estado atual de c1 
 c2 = main.MyContract(1, c1.data.myParameter1)
    cenário += c2 
 cenário.verify(c2.data.myParameter2 == 151)

Executando o Contrato e Testes

Seu contrato completo agora deve ser assim:

Python 
 import smartpy as sp 

 # Este é o editor SmartPy.
# Você pode experimentar o SmartPy carregando um modelo.
# (no menu Comandos acima deste editor) 
 # 
 # Um programa SmartPy típico tem o seguinte formato: 


 # Um módulo SmartPy 
 @sp.module 
 def main(): 
 # Uma classe de contratos 
 class MyContract(sp .Contrato): 
 def __init__(self, meuParâmetro1, meuParâmetro2): 
 self.data.myParameter1 = meuParâmetro1 
 self.data.meuParâmetro2 = myParameter2 

 # Um ponto de entrada, ou seja, um receptor de mensagens 
 # (os contratos reagem às mensagens) 
 @sp.entrypoint 
 def myEntryPoint(self, params): 
 assert self.data.myParameter1 <= 123 
 self.data.myParameter1 += params 


 # Testes 
 @sp.add_test(name="Bem-vindo") 
 def test(): 
 # Definimos um cenário de teste, juntamente com algumas saídas e verificações 
 # O cenário toma o módulo como parâmetro 
 cenário = sp.test_scenario(principal)
    cenário.h1("Bem-vindo")

    # Primeiro definimos um contrato e o adicionamos ao cenário 
 c1 = main.MyContract(12, 123) 
 cenário += c1 

 # E chamamos alguns de seus pontos de entrada 
 c1.myEntryPoint(12) 
 c1.myEntryPoint(13) 
 c1.myEntryPoint(14) 
 c1.myEntryPoint(50) 
 c1.myEntryPoint(50) 
 c1.myEntryPoint(50).run(válido=Falso)  # espera-se que isso falhe 

 # Finalmente, verificamos seu armazenamento final 
 cenário.verify(c1.data.myParameter1 == 151) 

 # Podemos definir outro contrato usando o estado atual de c1 
 c2 = main.MyContract(1, c1.data.myParameter1)
    cenário += c2 
 cenário.verify(c2.data.myParameter2 == 151)

Depois de escrever seu contrato e testes, você poderá executá-los diretamente no IDE. Clique no botão “Executar” no canto superior direito do IDE. O IDE compilará seu contrato, executará os testes e exibirá a saída junto com uma explicação detalhada de cada operação e mudança de estado.

Concluindo, esta lição apresentou o blockchain Tezos e o SmartPy, a linguagem de contrato inteligente do Tezos. Você também escreveu, entendeu e testou seu primeiro contrato SmartPy. Este é apenas o começo – há muito mais para aprender e fazer com SmartPy e Tezos. Esperamos que você esteja animado para continuar nesta jornada conosco nas próximas lições!