A blockchain Cardano é uma das blockchains de crescimento mais rápido e mais usada em 2022. A blockchain Cardano é uma plataforma blockchain de prova de participação (proof-of-stake) de terceira geração e lar da criptomoeda ADA.
Neste tutorial, mostraremos como construir um DApp na blockchain Cardano. Abordaremos o seguinte:
Sumário
- O que é Cardano
- O que é uma blockchain?
- O que são DApps
- O que é ADA?
- Cardano e tokens nativos
- O que é Plutus?
- Escrevendo contratos inteligentes usando Plutus
- Exemplo: Escrevendo um aplicativo “Hello, World!” em Plutus
- Exemplo: Usando a função sayInput
- Conclusão
Vamos começar!
O que é Cardano?
A blockchain Cardano é uma nova blockchain baseada no algoritmo de consenso Shelley. Ela foi projetada para ser uma plataforma segura, escalável e fácil de usar para criar e executar aplicativos descentralizados.
Shelley é uma pilha de software que fornece uma camada de abstração sobre as blockchains subjacentes.
O que é uma blockchain?
Uma blockchain é um banco de dados distribuído de registros vinculados por uma série de provas criptográficas. Os registros são chamados de blocos; a blockchain é uma coleção de blocos.
Ethereum é uma blockchain baseada na Máquina Virtual Ethereum. Para fazer transações na blockchain Ethereum, gastaremos alguns Ethers. Esta é a criptomoeda que é usada para pagar o gás na blockchain Ethereum.
Da mesma forma, na blockchain Cardano, gastaremos ADA para pagar as taxas de gás.
O que são DApps?
Um aplicativo descentralizado e distribuído é uma aplicação que não é controlada por uma entidade única. Caso contrário, um DApp seria como qualquer aplicativo convencional. Um DApp pode ser um aplicativo da Web, aplicativo de linha de comando, aplicativo de desktop ou dispositivo móvel.
A diferença entre um DApp e um aplicativo convencional é que o aplicativo convencional é controlado por uma entidade única. Um DApp tem uma blockchain como seu back-end.
Por exemplo, um aplicativo de tarefas React pode ter seus dados (as tarefas) armazenados em uma blockchain Ethereum. Ou você pode construir um sistema de votação em Angular e ter seus dados armazenados na blockchain Cardano.
O que é ADA?
Como mencionado acima, ADA é a criptomoeda nativa da blockchain Cardano. Você pode usar e transferir ADA na blockchain Cardano, assim como faria com ETH na blockchain Ethereum.
ADA pode ser usada tanto como criptomoeda quanto como token. ADA sendo usada como moeda nativa de Cardano significa que é:
- Aceita como pagamento de taxa
- Aceita para fazer depósitos
- A única moeda em que as recompensas são distribuídas
Assim como o ETH é dividido em denominações (por exemplo, Wei), a ADA também possui denominações. Lovelace é a menor unidade de ADA; 1 ADA é igual a 10^(-18) Lovelace, que pode ser dividido em um total de 1.000.000 de Lovelaces.
Cardano e tokens nativos
A blockchain Cardano possibilita a construção de tokens nativos. Esses tokens podem ser usados para representar um valor e negociar na blockchain Cardano.
Os tokens podem ser fungíveis ou não fungíveis. Os tokens fungíveis representam um valor, enquanto os tokens não fungíveis representam itens do mundo real (por exemplo, um carro ou uma obra de arte).
Nas seções a seguir, veremos como escrever e criar contratos inteligentes na blockchain Cardano usando a linguagem de programação Plutus.
O que é Plutus?
Plutus é uma linguagem de programação usada para escrever contratos inteligentes na blockchain Cardano. Outras linguagens de programação que você pode usar para a blockchain Cardano incluem Glow lang, Marlowe, etc., mas Plutus é a mais rápida entre elas.
Plutus é baseada em Haskell, portanto, usá-la requer conhecimento prévio de programação em Haskell.
Escrevendo contratos inteligentes usando Plutus
Vamos ver como escrever contratos inteligentes usando a linguagem de programação Plutus. Esses aplicativos podem ser executados off-chain e gerenciar instâncias de contrato ativos.
De acordo com a Cardano Testnets, os contratos Plutus consistem em partes que são executadas na blockchain (código on-chain) e partes que são executadas na máquina de um usuário (off-chain ou código do cliente). Escreveremos nossos contratos inteligentes em um editor e simulador online Plutus.
Um contrato inteligente Plutus é um código Haskell que é executado na carteira de um usuário e envia código para a blockchain para ser executado pelos nós na blockchain. Os contratos inteligentes são executados na blockchain, não na máquina do usuário.
Os contratos inteligentes Plutus têm definições que são usadas para definir o contrato inteligente e seu estado. Dentro dessas definições estão os pontos de extremidades, que definem o comportamento do contrato inteligente. Esses pontos de extremidades são funções executadas pela carteira. Eles são conhecidos como funções off-chain e são usados para construir transações e enviá-las para a blockchain.
Exemplo: Escrevendo um aplicativo “Hello, World!” em Plutus
Vamos escrever um DApp simples na blockchain Cardano usando a linguagem de programação Plutus.
Mais artigos excelentes da LogRocket: (Em inglês)
- Não perca um momento com The Replay, um boletim informativo com curadoria da LogRocket
- Saiba como o Galileo da LogRocket elimina o ruído para resolver problemas de forma proativa em seu aplicativo
- Use useEffect do React para otimizar o desempenho do seu aplicativo
- Alternar entre várias versões do Node
- Descubra como animar seu aplicativo React com AnimXYZ
- Explore Tauri, um novo framework para construir binários
- Compare NestJS x Express.js
Vamos escrever um contrato inteligente que imprimirá “Hello, World!” para o console.
Abra o editor e simulador online do Plutus.
import Data.Text qualified as T
import Playground.Contract
import Plutus.Contract
import PlutusTx.Prelude
import Prelude qualified as Haskell
-- | Um 'Contrato' que registra uma mensagem.
hello :: Contract () EmptySchema T.Text ()
hello = logInfo @Haskell.String "Hello, world"
endpoints :: Contract () EmptySchema T.Text ()
endpoints = hello
type DummySchema = Endpoint "dummy" ()
mkSchemaDefinitions ''DummySchema
$(mkKnownCurrencies [])
O acima mencionado já será preenchido para nós. Vamos ao código:
import Data.Text qualified as T
import Playground.Contract
import Plutus.Contract
import PlutusTx.Prelude
import Prelude qualified as Haskell
Aqui, importamos as bibliotecas e funções internas que precisaremos:
- A biblioteca
Data.Texté usada para converter strings em texto - O
Playground.Contractimporta as interfaces inteligentes do contrato definidas no playground - A biblioteca
Plutus.Contracté usada para definir o contrato inteligente da biblioteca principal do Plutus - A biblioteca
PlutusTx.PreludePlutusTxsubstitui a biblioteca Haskell Prelude normal e inclui funções que são refinadas e mais fáceis para o compilador compilar
hello :: Contract () EmptySchema T.Text ()
hello = logInfo @Haskell.String "Hello, world"
O acima mencionado define uma função hello. O Contract () EmptySchema T.Text ()diz ao compilador que a função não retornará nada. A função logInfoé uma função interna que registra uma mensagem no console. Então, em resumo, a função helloserá registrada no console como Hello, world.
endpoints :: Contract () EmptySchema T.Text ()
endpoints = hello
Isso cria uma função endpoints, que será usada para executar a função hello. Isso expõe a função hello à blockchain.
type DummySchema = Endpoint "dummy" ()
mkSchemaDefinitions ''DummySchema
$(mkKnownCurrencies [])
O mencionado acima cria o tipo DummySchema, que é usado para definir o estado do contrato inteligente. Por fim, expõe os pontos de extremidades à blockchain.
Em nosso playground Plutus, podemos clicar no botão verde Compile para compilar nossos contratos. O botão azul Simulate abrirá uma página onde podemos executar os contratos inteligentes na blockchain.
Clique no botão verde Compile. Após uma compilação bem-sucedida, o botão azul Simulale abrirá uma página onde podemos executar os contratos inteligentes na blockchain:
Você notará que temos duas carteiras, cada uma com um saldo aberto de 100 Lovelaces. As funções Available em cada carteira mostrarão as funções que estão disponíveis para serem utilizadas.
No nosso caso, vemos nossa função hello e outra funçãoPay to Wallet. A função Pay to Walleté usada para enviar fundos para outra carteira e é definida pelo contrato Plutus. Não conseguimos ver o código porque ele é adicionado lá quando importamos os módulos abaixo:
import Playground.Contract
import Plutus.Contract
Se olharmos na parte abaixo da página, veremos uma seção de Actions. Esta seção é onde as funções que queremos executar são adicionadas quando o cartão de endereços da carteira acima é clicado.
Já temos um cartão na Actions, o cartão simula atraso na blockchain. Podemos remover este cartão clicando no ícone “X”.
Agora, clique no botão dummy e você verá um cartão aparecer na seção Actions:
Clique no botão verde Evaluate e você verá a função hello executada na blockchain. Depois de algum tempo, uma página Transactions aparecerá:
Role para baixo até a seção Logs e você verá o registro da função hello, Hello, worldno console:
Exemplo: Usando a função sayInput
Vamos escrever outro programa que pegue uma string e a imprima no console.
Adicione o código abaixo ao seu editor online Plutus:
import Data.Text qualified as T
import Playground.Contract
import Plutus.Contract
import PlutusTx.Prelude
import Prelude qualified as Haskell
type Schema =
Endpoint "sayInput" Haskell.String
contract :: AsContractError e => Contract () Schema e ()
contract = selectList [sayInput]
-- | O ponto de extremidade do contrato "sayInput".
sayInput :: AsContractError e => Promise () Schema e ()
sayInput = endpoint @"sayInput" $ \inputValue -> do
logInfo @Haskell.String $ inputValue
endpoints :: AsContractError e => Contract () Schema e ()
endpoints = contract
mkSchemaDefinitions ''Schema
$(mkKnownCurrencies [])
Já vimos a primeira parte do código; aqui, importamos as bibliotecas necessárias para executar o aplicativo.
Em seguida, definimos um tipo Schema. Esse tipo é usado para definir o estado do contrato inteligente. Depois disso, configuramos uma lista de pontos de extremidade do contrato e adicionamos o ponto de extremidade sayInput.
Também definimos o ponto de extremidade sayInput, que recebe uma string como entrada e a registra no console.
Por fim, disponibilizamos o ponto de extremidade para a blockchain.
Clique no botão verde Compile. Após uma compilação bem-sucedida, você deverá ver isto:
Clique no botão azul Simulate. Isso abrirá uma página onde podemos executar os contratos inteligentes na blockchain.
Observe que temos a função sayInput nos endereços da carteira. Clique nisso.
A função sayInput aparecerá na seção Actions:
Agora, digite qualquer string no campo de entrada e clique no botão Evaluate:
Você verá a string que digitou na página Transactions.
Conclusão
Neste tutorial, demonstramos como escrever um DApp na blockchain Cardano usando a linguagem de programação Plutus.
Começamos apresentando a blockchain Cardano e a linguagem de programação Plutus. Em seguida, explicamos sobre a Cardano comparando-a com a blockchain Ethereum. Em seguida, apresentamos a linguagem de programação Plutus e descrevemos como podemos usá-la para compilar e executar contratos inteligentes na blockchain Cardano.
Por fim, passamos por alguns exemplos de contratos inteligentes escritos na linguagem de programação Plutus e executados em uma blockchain Cardano simulada.
Junte-se a organizações como Bitso e Coinsquare que usam LogRocket para monitorar proativamente seus aplicativos Web3
Problemas do lado do cliente que afetam a capacidade dos usuários de ativar e realizar transações em seus aplicativos podem afetar drasticamente seus resultados. Se você estiver interessado em monitorar problemas de UX (experiência do usuário), exibir automaticamente erros de JavaScript e rastrear solicitações de rede lentas e tempo de carregamento de componentes, experimente o LogRocket.
O LogRocket é como um DVR (gravador de vídeo digital) para aplicativos da web e aplicativos móveis, gravando tudo o que acontece em seu aplicativo ou site da web. Em vez de adivinhar por que os problemas acontecem, você pode agregar e relatar as principais métricas de desempenho de front-end, reproduzir sessões de usuário junto com o estado do aplicativo, registrar solicitações de rede e exibir automaticamente todos os erros.
Modernize a forma como você depura aplicativos móveis e da Web — comece a monitorar gratuitamente.
Artigo escrito por Chidume Nnamdi e traduzido por Marcelo Panegali
Abrace a oportunidade de elevar sua jornada de desenvolvimento para um nível superior.📚💡
A construção de DApps é apenas o começo; os builds incríveis da WEB3DEV representam a chave de entrada para o emocionante cenário web3. 🚀🧑💻
👉 Não perca tempo, inscreva-se agora mesmo e comece a desbravar o universo Blockchain! Seja também WEB3DEV 👈
Oldest comments (0)